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

#ifndef GOOGLE_PROTOBUF_INCLUDED_common_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_common_2eproto

#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3009000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers. Please update
#error your headers.
#endif
#if 3009001 < PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
#endif

#include <google/protobuf/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_table_driven.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/inlined_string_field.h>
#include <google/protobuf/metadata.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>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_common_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_common_2eproto {
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxillaryParseTableField aux[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[30]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_common_2eproto;
class AlarmMsg;
class AlarmMsgDefaultTypeInternal;
extern AlarmMsgDefaultTypeInternal _AlarmMsg_default_instance_;
class AlarmsMsg;
class AlarmsMsgDefaultTypeInternal;
extern AlarmsMsgDefaultTypeInternal _AlarmsMsg_default_instance_;
class CameraDataMsg;
class CameraDataMsgDefaultTypeInternal;
extern CameraDataMsgDefaultTypeInternal _CameraDataMsg_default_instance_;
class DataBlockMsg;
class DataBlockMsgDefaultTypeInternal;
extern DataBlockMsgDefaultTypeInternal _DataBlockMsg_default_instance_;
class ErrorMsg;
class ErrorMsgDefaultTypeInternal;
extern ErrorMsgDefaultTypeInternal _ErrorMsg_default_instance_;
class JobInfoMsg;
class JobInfoMsgDefaultTypeInternal;
extern JobInfoMsgDefaultTypeInternal _JobInfoMsg_default_instance_;
class JobMsg;
class JobMsgDefaultTypeInternal;
extern JobMsgDefaultTypeInternal _JobMsg_default_instance_;
class JobParamMsg;
class JobParamMsgDefaultTypeInternal;
extern JobParamMsgDefaultTypeInternal _JobParamMsg_default_instance_;
class JobStateMsg;
class JobStateMsgDefaultTypeInternal;
extern JobStateMsgDefaultTypeInternal _JobStateMsg_default_instance_;
class LayerDataBlockMsg;
class LayerDataBlockMsgDefaultTypeInternal;
extern LayerDataBlockMsgDefaultTypeInternal _LayerDataBlockMsg_default_instance_;
class LayerDataReqMsg;
class LayerDataReqMsgDefaultTypeInternal;
extern LayerDataReqMsgDefaultTypeInternal _LayerDataReqMsg_default_instance_;
class LayerDataRespMsg;
class LayerDataRespMsgDefaultTypeInternal;
extern LayerDataRespMsgDefaultTypeInternal _LayerDataRespMsg_default_instance_;
class LayerImageDataMsg;
class LayerImageDataMsgDefaultTypeInternal;
extern LayerImageDataMsgDefaultTypeInternal _LayerImageDataMsg_default_instance_;
class LayerImageMsg;
class LayerImageMsgDefaultTypeInternal;
extern LayerImageMsgDefaultTypeInternal _LayerImageMsg_default_instance_;
class LayerImagesMsg;
class LayerImagesMsgDefaultTypeInternal;
extern LayerImagesMsgDefaultTypeInternal _LayerImagesMsg_default_instance_;
class LayerLoadCurveDataMsg;
class LayerLoadCurveDataMsgDefaultTypeInternal;
extern LayerLoadCurveDataMsgDefaultTypeInternal _LayerLoadCurveDataMsg_default_instance_;
class LayerLoadCurveMsg;
class LayerLoadCurveMsgDefaultTypeInternal;
extern LayerLoadCurveMsgDefaultTypeInternal _LayerLoadCurveMsg_default_instance_;
class LayerLoadCurvesMsg;
class LayerLoadCurvesMsgDefaultTypeInternal;
extern LayerLoadCurvesMsgDefaultTypeInternal _LayerLoadCurvesMsg_default_instance_;
class LayerStateMsg;
class LayerStateMsgDefaultTypeInternal;
extern LayerStateMsgDefaultTypeInternal _LayerStateMsg_default_instance_;
class LayerStatesMsg;
class LayerStatesMsgDefaultTypeInternal;
extern LayerStatesMsgDefaultTypeInternal _LayerStatesMsg_default_instance_;
class LogFetchReqMsg;
class LogFetchReqMsgDefaultTypeInternal;
extern LogFetchReqMsgDefaultTypeInternal _LogFetchReqMsg_default_instance_;
class LogReqMsg;
class LogReqMsgDefaultTypeInternal;
extern LogReqMsgDefaultTypeInternal _LogReqMsg_default_instance_;
class LogRespMsg;
class LogRespMsgDefaultTypeInternal;
extern LogRespMsgDefaultTypeInternal _LogRespMsg_default_instance_;
class MachineMsg;
class MachineMsgDefaultTypeInternal;
extern MachineMsgDefaultTypeInternal _MachineMsg_default_instance_;
class ParameterMsg;
class ParameterMsgDefaultTypeInternal;
extern ParameterMsgDefaultTypeInternal _ParameterMsg_default_instance_;
class PartMsg;
class PartMsgDefaultTypeInternal;
extern PartMsgDefaultTypeInternal _PartMsg_default_instance_;
class ResponseState;
class ResponseStateDefaultTypeInternal;
extern ResponseStateDefaultTypeInternal _ResponseState_default_instance_;
class StateMsg;
class StateMsgDefaultTypeInternal;
extern StateMsgDefaultTypeInternal _StateMsg_default_instance_;
class TaskMsg;
class TaskMsgDefaultTypeInternal;
extern TaskMsgDefaultTypeInternal _TaskMsg_default_instance_;
class TasksMsg;
class TasksMsgDefaultTypeInternal;
extern TasksMsgDefaultTypeInternal _TasksMsg_default_instance_;
PROTOBUF_NAMESPACE_OPEN
template<> ::AlarmMsg* Arena::CreateMaybeMessage<::AlarmMsg>(Arena*);
template<> ::AlarmsMsg* Arena::CreateMaybeMessage<::AlarmsMsg>(Arena*);
template<> ::CameraDataMsg* Arena::CreateMaybeMessage<::CameraDataMsg>(Arena*);
template<> ::DataBlockMsg* Arena::CreateMaybeMessage<::DataBlockMsg>(Arena*);
template<> ::ErrorMsg* Arena::CreateMaybeMessage<::ErrorMsg>(Arena*);
template<> ::JobInfoMsg* Arena::CreateMaybeMessage<::JobInfoMsg>(Arena*);
template<> ::JobMsg* Arena::CreateMaybeMessage<::JobMsg>(Arena*);
template<> ::JobParamMsg* Arena::CreateMaybeMessage<::JobParamMsg>(Arena*);
template<> ::JobStateMsg* Arena::CreateMaybeMessage<::JobStateMsg>(Arena*);
template<> ::LayerDataBlockMsg* Arena::CreateMaybeMessage<::LayerDataBlockMsg>(Arena*);
template<> ::LayerDataReqMsg* Arena::CreateMaybeMessage<::LayerDataReqMsg>(Arena*);
template<> ::LayerDataRespMsg* Arena::CreateMaybeMessage<::LayerDataRespMsg>(Arena*);
template<> ::LayerImageDataMsg* Arena::CreateMaybeMessage<::LayerImageDataMsg>(Arena*);
template<> ::LayerImageMsg* Arena::CreateMaybeMessage<::LayerImageMsg>(Arena*);
template<> ::LayerImagesMsg* Arena::CreateMaybeMessage<::LayerImagesMsg>(Arena*);
template<> ::LayerLoadCurveDataMsg* Arena::CreateMaybeMessage<::LayerLoadCurveDataMsg>(Arena*);
template<> ::LayerLoadCurveMsg* Arena::CreateMaybeMessage<::LayerLoadCurveMsg>(Arena*);
template<> ::LayerLoadCurvesMsg* Arena::CreateMaybeMessage<::LayerLoadCurvesMsg>(Arena*);
template<> ::LayerStateMsg* Arena::CreateMaybeMessage<::LayerStateMsg>(Arena*);
template<> ::LayerStatesMsg* Arena::CreateMaybeMessage<::LayerStatesMsg>(Arena*);
template<> ::LogFetchReqMsg* Arena::CreateMaybeMessage<::LogFetchReqMsg>(Arena*);
template<> ::LogReqMsg* Arena::CreateMaybeMessage<::LogReqMsg>(Arena*);
template<> ::LogRespMsg* Arena::CreateMaybeMessage<::LogRespMsg>(Arena*);
template<> ::MachineMsg* Arena::CreateMaybeMessage<::MachineMsg>(Arena*);
template<> ::ParameterMsg* Arena::CreateMaybeMessage<::ParameterMsg>(Arena*);
template<> ::PartMsg* Arena::CreateMaybeMessage<::PartMsg>(Arena*);
template<> ::ResponseState* Arena::CreateMaybeMessage<::ResponseState>(Arena*);
template<> ::StateMsg* Arena::CreateMaybeMessage<::StateMsg>(Arena*);
template<> ::TaskMsg* Arena::CreateMaybeMessage<::TaskMsg>(Arena*);
template<> ::TasksMsg* Arena::CreateMaybeMessage<::TasksMsg>(Arena*);
PROTOBUF_NAMESPACE_CLOSE

enum StateMsg_PrintState : int {
  StateMsg_PrintState_STANDBY = 0,
  StateMsg_PrintState_STANDBY_PAUSE = 1,
  StateMsg_PrintState_STANDBY_STOP = 2,
  StateMsg_PrintState_PREPRINT = 3,
  StateMsg_PrintState_PRINTING = 4,
  StateMsg_PrintState_FINISH = 5,
  StateMsg_PrintState_PAUSE = 6,
  StateMsg_PrintState_STOP = 7,
  StateMsg_PrintState_StateMsg_PrintState_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  StateMsg_PrintState_StateMsg_PrintState_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool StateMsg_PrintState_IsValid(int value);
constexpr StateMsg_PrintState StateMsg_PrintState_PrintState_MIN = StateMsg_PrintState_STANDBY;
constexpr StateMsg_PrintState StateMsg_PrintState_PrintState_MAX = StateMsg_PrintState_STOP;
constexpr int StateMsg_PrintState_PrintState_ARRAYSIZE = StateMsg_PrintState_PrintState_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* StateMsg_PrintState_descriptor();
template<typename T>
inline const std::string& StateMsg_PrintState_Name(T enum_t_value) {
  static_assert(::std::is_same<T, StateMsg_PrintState>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function StateMsg_PrintState_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    StateMsg_PrintState_descriptor(), enum_t_value);
}
inline bool StateMsg_PrintState_Parse(
    const std::string& name, StateMsg_PrintState* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<StateMsg_PrintState>(
    StateMsg_PrintState_descriptor(), name, value);
}
enum JobStateMsg_JobState : int {
  JobStateMsg_JobState_START = 0,
  JobStateMsg_JobState_STOP = 1,
  JobStateMsg_JobState_JobStateMsg_JobState_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  JobStateMsg_JobState_JobStateMsg_JobState_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool JobStateMsg_JobState_IsValid(int value);
constexpr JobStateMsg_JobState JobStateMsg_JobState_JobState_MIN = JobStateMsg_JobState_START;
constexpr JobStateMsg_JobState JobStateMsg_JobState_JobState_MAX = JobStateMsg_JobState_STOP;
constexpr int JobStateMsg_JobState_JobState_ARRAYSIZE = JobStateMsg_JobState_JobState_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* JobStateMsg_JobState_descriptor();
template<typename T>
inline const std::string& JobStateMsg_JobState_Name(T enum_t_value) {
  static_assert(::std::is_same<T, JobStateMsg_JobState>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function JobStateMsg_JobState_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    JobStateMsg_JobState_descriptor(), enum_t_value);
}
inline bool JobStateMsg_JobState_Parse(
    const std::string& name, JobStateMsg_JobState* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<JobStateMsg_JobState>(
    JobStateMsg_JobState_descriptor(), name, value);
}
enum MachineMsg_MachineType : int {
  MachineMsg_MachineType_HBD_100 = 0,
  MachineMsg_MachineType_HBD_280 = 1,
  MachineMsg_MachineType_HBD_80 = 2,
  MachineMsg_MachineType_HBD_400 = 3,
  MachineMsg_MachineType_MachineMsg_MachineType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  MachineMsg_MachineType_MachineMsg_MachineType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool MachineMsg_MachineType_IsValid(int value);
constexpr MachineMsg_MachineType MachineMsg_MachineType_MachineType_MIN = MachineMsg_MachineType_HBD_100;
constexpr MachineMsg_MachineType MachineMsg_MachineType_MachineType_MAX = MachineMsg_MachineType_HBD_400;
constexpr int MachineMsg_MachineType_MachineType_ARRAYSIZE = MachineMsg_MachineType_MachineType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* MachineMsg_MachineType_descriptor();
template<typename T>
inline const std::string& MachineMsg_MachineType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, MachineMsg_MachineType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function MachineMsg_MachineType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    MachineMsg_MachineType_descriptor(), enum_t_value);
}
inline bool MachineMsg_MachineType_Parse(
    const std::string& name, MachineMsg_MachineType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<MachineMsg_MachineType>(
    MachineMsg_MachineType_descriptor(), name, value);
}
enum MachineMsg_PurifierType : int {
  MachineMsg_PurifierType_HBD_PURIFIER_1 = 0,
  MachineMsg_PurifierType_XT = 1,
  MachineMsg_PurifierType_HBD_PURIFIER_2 = 2,
  MachineMsg_PurifierType_MachineMsg_PurifierType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  MachineMsg_PurifierType_MachineMsg_PurifierType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool MachineMsg_PurifierType_IsValid(int value);
constexpr MachineMsg_PurifierType MachineMsg_PurifierType_PurifierType_MIN = MachineMsg_PurifierType_HBD_PURIFIER_1;
constexpr MachineMsg_PurifierType MachineMsg_PurifierType_PurifierType_MAX = MachineMsg_PurifierType_HBD_PURIFIER_2;
constexpr int MachineMsg_PurifierType_PurifierType_ARRAYSIZE = MachineMsg_PurifierType_PurifierType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* MachineMsg_PurifierType_descriptor();
template<typename T>
inline const std::string& MachineMsg_PurifierType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, MachineMsg_PurifierType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function MachineMsg_PurifierType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    MachineMsg_PurifierType_descriptor(), enum_t_value);
}
inline bool MachineMsg_PurifierType_Parse(
    const std::string& name, MachineMsg_PurifierType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<MachineMsg_PurifierType>(
    MachineMsg_PurifierType_descriptor(), name, value);
}
enum ErrorMsg_ErrorType : int {
  ErrorMsg_ErrorType_STOP = 0,
  ErrorMsg_ErrorType_PAUSE = 1,
  ErrorMsg_ErrorType_ErrorMsg_ErrorType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  ErrorMsg_ErrorType_ErrorMsg_ErrorType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool ErrorMsg_ErrorType_IsValid(int value);
constexpr ErrorMsg_ErrorType ErrorMsg_ErrorType_ErrorType_MIN = ErrorMsg_ErrorType_STOP;
constexpr ErrorMsg_ErrorType ErrorMsg_ErrorType_ErrorType_MAX = ErrorMsg_ErrorType_PAUSE;
constexpr int ErrorMsg_ErrorType_ErrorType_ARRAYSIZE = ErrorMsg_ErrorType_ErrorType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ErrorMsg_ErrorType_descriptor();
template<typename T>
inline const std::string& ErrorMsg_ErrorType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, ErrorMsg_ErrorType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function ErrorMsg_ErrorType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    ErrorMsg_ErrorType_descriptor(), enum_t_value);
}
inline bool ErrorMsg_ErrorType_Parse(
    const std::string& name, ErrorMsg_ErrorType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ErrorMsg_ErrorType>(
    ErrorMsg_ErrorType_descriptor(), name, value);
}
enum LogReqMsg_LogType : int {
  LogReqMsg_LogType_ALARM = 0,
  LogReqMsg_LogType_TASK = 1,
  LogReqMsg_LogType_LAYERSTATE = 2,
  LogReqMsg_LogType_LAYERIMAGE = 3,
  LogReqMsg_LogType_IMAGE = 4,
  LogReqMsg_LogType_LAYERLOADCURVE = 5,
  LogReqMsg_LogType_LOADCURVE = 6,
  LogReqMsg_LogType_LogReqMsg_LogType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  LogReqMsg_LogType_LogReqMsg_LogType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool LogReqMsg_LogType_IsValid(int value);
constexpr LogReqMsg_LogType LogReqMsg_LogType_LogType_MIN = LogReqMsg_LogType_ALARM;
constexpr LogReqMsg_LogType LogReqMsg_LogType_LogType_MAX = LogReqMsg_LogType_LOADCURVE;
constexpr int LogReqMsg_LogType_LogType_ARRAYSIZE = LogReqMsg_LogType_LogType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* LogReqMsg_LogType_descriptor();
template<typename T>
inline const std::string& LogReqMsg_LogType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, LogReqMsg_LogType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function LogReqMsg_LogType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    LogReqMsg_LogType_descriptor(), enum_t_value);
}
inline bool LogReqMsg_LogType_Parse(
    const std::string& name, LogReqMsg_LogType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<LogReqMsg_LogType>(
    LogReqMsg_LogType_descriptor(), name, value);
}
enum LogFetchReqMsg_LogType : int {
  LogFetchReqMsg_LogType_ALARM = 0,
  LogFetchReqMsg_LogType_TASKLIST = 1,
  LogFetchReqMsg_LogType_TASK = 2,
  LogFetchReqMsg_LogType_LogFetchReqMsg_LogType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  LogFetchReqMsg_LogType_LogFetchReqMsg_LogType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool LogFetchReqMsg_LogType_IsValid(int value);
constexpr LogFetchReqMsg_LogType LogFetchReqMsg_LogType_LogType_MIN = LogFetchReqMsg_LogType_ALARM;
constexpr LogFetchReqMsg_LogType LogFetchReqMsg_LogType_LogType_MAX = LogFetchReqMsg_LogType_TASK;
constexpr int LogFetchReqMsg_LogType_LogType_ARRAYSIZE = LogFetchReqMsg_LogType_LogType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* LogFetchReqMsg_LogType_descriptor();
template<typename T>
inline const std::string& LogFetchReqMsg_LogType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, LogFetchReqMsg_LogType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function LogFetchReqMsg_LogType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    LogFetchReqMsg_LogType_descriptor(), enum_t_value);
}
inline bool LogFetchReqMsg_LogType_Parse(
    const std::string& name, LogFetchReqMsg_LogType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<LogFetchReqMsg_LogType>(
    LogFetchReqMsg_LogType_descriptor(), name, value);
}
// ===================================================================

class StateMsg :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:StateMsg) */ {
 public:
  StateMsg();
  virtual ~StateMsg();

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

  inline StateMsg& operator=(const StateMsg& from) {
    CopyFrom(from);
    return *this;
  }
  inline StateMsg& operator=(StateMsg&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const StateMsg& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const StateMsg* internal_default_instance() {
    return reinterpret_cast<const StateMsg*>(
               &_StateMsg_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

  friend void swap(StateMsg& a, StateMsg& b) {
    a.Swap(&b);
  }
  inline void Swap(StateMsg* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline StateMsg* New() const final {
    return CreateMaybeMessage<StateMsg>(nullptr);
  }

  StateMsg* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<StateMsg>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const StateMsg& from);
  void MergeFrom(const StateMsg& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(StateMsg* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "StateMsg";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_common_2eproto);
    return ::descriptor_table_common_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

  typedef StateMsg_PrintState PrintState;
  static constexpr PrintState STANDBY =
    StateMsg_PrintState_STANDBY;
  static constexpr PrintState STANDBY_PAUSE =
    StateMsg_PrintState_STANDBY_PAUSE;
  static constexpr PrintState STANDBY_STOP =
    StateMsg_PrintState_STANDBY_STOP;
  static constexpr PrintState PREPRINT =
    StateMsg_PrintState_PREPRINT;
  static constexpr PrintState PRINTING =
    StateMsg_PrintState_PRINTING;
  static constexpr PrintState FINISH =
    StateMsg_PrintState_FINISH;
  static constexpr PrintState PAUSE =
    StateMsg_PrintState_PAUSE;
  static constexpr PrintState STOP =
    StateMsg_PrintState_STOP;
  static inline bool PrintState_IsValid(int value) {
    return StateMsg_PrintState_IsValid(value);
  }
  static constexpr PrintState PrintState_MIN =
    StateMsg_PrintState_PrintState_MIN;
  static constexpr PrintState PrintState_MAX =
    StateMsg_PrintState_PrintState_MAX;
  static constexpr int PrintState_ARRAYSIZE =
    StateMsg_PrintState_PrintState_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  PrintState_descriptor() {
    return StateMsg_PrintState_descriptor();
  }
  template<typename T>
  static inline const std::string& PrintState_Name(T enum_t_value) {
    static_assert(::std::is_same<T, PrintState>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function PrintState_Name.");
    return StateMsg_PrintState_Name(enum_t_value);
  }
  static inline bool PrintState_Parse(const std::string& name,
      PrintState* value) {
    return StateMsg_PrintState_Parse(name, value);
  }

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

  enum : int {
    kMachineIdFieldNumber = 13,
    kMaterialFieldNumber = 20,
    kOxygenValueFieldNumber = 1,
    kAmbientTempFieldNumber = 2,
    kInnerTempFieldNumber = 3,
    kWindValueFieldNumber = 4,
    kPlatformTempValueFieldNumber = 5,
    kPlatformTempSettingValueFieldNumber = 6,
    kMoldPosFieldNumber = 7,
    kPowderPosFieldNumber = 8,
    kArmPosFieldNumber = 9,
    kPrintStateFieldNumber = 10,
    kLayerIndexFieldNumber = 11,
    kLimitFlagFieldNumber = 12,
    kIsDoorCloseFieldNumber = 14,
    kAccTimeFieldNumber = 15,
    kRemainTimeFieldNumber = 16,
    kTotalTimeFieldNumber = 17,
    kPrintTimeFieldNumber = 19,
    kLayerCountFieldNumber = 18,
  };
  // string machineId = 13;
  void clear_machineid();
  const std::string& machineid() const;
  void set_machineid(const std::string& value);
  void set_machineid(std::string&& value);
  void set_machineid(const char* value);
  void set_machineid(const char* value, size_t size);
  std::string* mutable_machineid();
  std::string* release_machineid();
  void set_allocated_machineid(std::string* machineid);

  // string material = 20;
  void clear_material();
  const std::string& material() const;
  void set_material(const std::string& value);
  void set_material(std::string&& value);
  void set_material(const char* value);
  void set_material(const char* value, size_t size);
  std::string* mutable_material();
  std::string* release_material();
  void set_allocated_material(std::string* material);

  // float oxygenValue = 1;
  void clear_oxygenvalue();
  float oxygenvalue() const;
  void set_oxygenvalue(float value);

  // float ambientTemp = 2;
  void clear_ambienttemp();
  float ambienttemp() const;
  void set_ambienttemp(float value);

  // float innerTemp = 3;
  void clear_innertemp();
  float innertemp() const;
  void set_innertemp(float value);

  // float windValue = 4;
  void clear_windvalue();
  float windvalue() const;
  void set_windvalue(float value);

  // float platformTempValue = 5;
  void clear_platformtempvalue();
  float platformtempvalue() const;
  void set_platformtempvalue(float value);

  // float platformTempSettingValue = 6;
  void clear_platformtempsettingvalue();
  float platformtempsettingvalue() const;
  void set_platformtempsettingvalue(float value);

  // float moldPos = 7;
  void clear_moldpos();
  float moldpos() const;
  void set_moldpos(float value);

  // float powderPos = 8;
  void clear_powderpos();
  float powderpos() const;
  void set_powderpos(float value);

  // float armPos = 9;
  void clear_armpos();
  float armpos() const;
  void set_armpos(float value);

  // .StateMsg.PrintState printState = 10;
  void clear_printstate();
  ::StateMsg_PrintState printstate() const;
  void set_printstate(::StateMsg_PrintState value);

  // int32 layerIndex = 11;
  void clear_layerindex();
  ::PROTOBUF_NAMESPACE_ID::int32 layerindex() const;
  void set_layerindex(::PROTOBUF_NAMESPACE_ID::int32 value);

  // int32 limitFlag = 12;
  void clear_limitflag();
  ::PROTOBUF_NAMESPACE_ID::int32 limitflag() const;
  void set_limitflag(::PROTOBUF_NAMESPACE_ID::int32 value);

  // bool isDoorClose = 14;
  void clear_isdoorclose();
  bool isdoorclose() const;
  void set_isdoorclose(bool value);

  // uint32 accTime = 15;
  void clear_acctime();
  ::PROTOBUF_NAMESPACE_ID::uint32 acctime() const;
  void set_acctime(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // uint32 remainTime = 16;
  void clear_remaintime();
  ::PROTOBUF_NAMESPACE_ID::uint32 remaintime() const;
  void set_remaintime(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // uint32 totalTime = 17;
  void clear_totaltime();
  ::PROTOBUF_NAMESPACE_ID::uint32 totaltime() const;
  void set_totaltime(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // int64 printTime = 19;
  void clear_printtime();
  ::PROTOBUF_NAMESPACE_ID::int64 printtime() const;
  void set_printtime(::PROTOBUF_NAMESPACE_ID::int64 value);

  // int32 layerCount = 18;
  void clear_layercount();
  ::PROTOBUF_NAMESPACE_ID::int32 layercount() const;
  void set_layercount(::PROTOBUF_NAMESPACE_ID::int32 value);

  // @@protoc_insertion_point(class_scope:StateMsg)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr machineid_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr material_;
  float oxygenvalue_;
  float ambienttemp_;
  float innertemp_;
  float windvalue_;
  float platformtempvalue_;
  float platformtempsettingvalue_;
  float moldpos_;
  float powderpos_;
  float armpos_;
  int printstate_;
  ::PROTOBUF_NAMESPACE_ID::int32 layerindex_;
  ::PROTOBUF_NAMESPACE_ID::int32 limitflag_;
  bool isdoorclose_;
  ::PROTOBUF_NAMESPACE_ID::uint32 acctime_;
  ::PROTOBUF_NAMESPACE_ID::uint32 remaintime_;
  ::PROTOBUF_NAMESPACE_ID::uint32 totaltime_;
  ::PROTOBUF_NAMESPACE_ID::int64 printtime_;
  ::PROTOBUF_NAMESPACE_ID::int32 layercount_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_common_2eproto;
};
// -------------------------------------------------------------------

class JobInfoMsg :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:JobInfoMsg) */ {
 public:
  JobInfoMsg();
  virtual ~JobInfoMsg();

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

  inline JobInfoMsg& operator=(const JobInfoMsg& from) {
    CopyFrom(from);
    return *this;
  }
  inline JobInfoMsg& operator=(JobInfoMsg&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const JobInfoMsg& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const JobInfoMsg* internal_default_instance() {
    return reinterpret_cast<const JobInfoMsg*>(
               &_JobInfoMsg_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

  friend void swap(JobInfoMsg& a, JobInfoMsg& b) {
    a.Swap(&b);
  }
  inline void Swap(JobInfoMsg* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline JobInfoMsg* New() const final {
    return CreateMaybeMessage<JobInfoMsg>(nullptr);
  }

  JobInfoMsg* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<JobInfoMsg>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const JobInfoMsg& from);
  void MergeFrom(const JobInfoMsg& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(JobInfoMsg* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "JobInfoMsg";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_common_2eproto);
    return ::descriptor_table_common_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kNameFieldNumber = 1,
    kMaterialFieldNumber = 5,
    kXSizeFieldNumber = 2,
    kYSizeFieldNumber = 3,
    kZSizeFieldNumber = 4,
    kLayerThicknessFieldNumber = 6,
    kLayerCountFieldNumber = 7,
    kComponentCountFieldNumber = 8,
    kVolumeFieldNumber = 9,
    kSupportVolumeFieldNumber = 10,
  };
  // string name = 1;
  void clear_name();
  const std::string& name() const;
  void set_name(const std::string& value);
  void set_name(std::string&& value);
  void set_name(const char* value);
  void set_name(const char* value, size_t size);
  std::string* mutable_name();
  std::string* release_name();
  void set_allocated_name(std::string* name);

  // string material = 5;
  void clear_material();
  const std::string& material() const;
  void set_material(const std::string& value);
  void set_material(std::string&& value);
  void set_material(const char* value);
  void set_material(const char* value, size_t size);
  std::string* mutable_material();
  std::string* release_material();
  void set_allocated_material(std::string* material);

  // float xSize = 2;
  void clear_xsize();
  float xsize() const;
  void set_xsize(float value);

  // float ySize = 3;
  void clear_ysize();
  float ysize() const;
  void set_ysize(float value);

  // float zSize = 4;
  void clear_zsize();
  float zsize() const;
  void set_zsize(float value);

  // float layerThickness = 6;
  void clear_layerthickness();
  float layerthickness() const;
  void set_layerthickness(float value);

  // uint32 layerCount = 7;
  void clear_layercount();
  ::PROTOBUF_NAMESPACE_ID::uint32 layercount() const;
  void set_layercount(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // uint32 componentCount = 8;
  void clear_componentcount();
  ::PROTOBUF_NAMESPACE_ID::uint32 componentcount() const;
  void set_componentcount(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // float volume = 9;
  void clear_volume();
  float volume() const;
  void set_volume(float value);

  // float supportVolume = 10;
  void clear_supportvolume();
  float supportvolume() const;
  void set_supportvolume(float value);

  // @@protoc_insertion_point(class_scope:JobInfoMsg)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr material_;
  float xsize_;
  float ysize_;
  float zsize_;
  float layerthickness_;
  ::PROTOBUF_NAMESPACE_ID::uint32 layercount_;
  ::PROTOBUF_NAMESPACE_ID::uint32 componentcount_;
  float volume_;
  float supportvolume_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_common_2eproto;
};
// -------------------------------------------------------------------

class JobStateMsg :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:JobStateMsg) */ {
 public:
  JobStateMsg();
  virtual ~JobStateMsg();

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

  inline JobStateMsg& operator=(const JobStateMsg& from) {
    CopyFrom(from);
    return *this;
  }
  inline JobStateMsg& operator=(JobStateMsg&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const JobStateMsg& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const JobStateMsg* internal_default_instance() {
    return reinterpret_cast<const JobStateMsg*>(
               &_JobStateMsg_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

  friend void swap(JobStateMsg& a, JobStateMsg& b) {
    a.Swap(&b);
  }
  inline void Swap(JobStateMsg* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline JobStateMsg* New() const final {
    return CreateMaybeMessage<JobStateMsg>(nullptr);
  }

  JobStateMsg* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<JobStateMsg>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const JobStateMsg& from);
  void MergeFrom(const JobStateMsg& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(JobStateMsg* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "JobStateMsg";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_common_2eproto);
    return ::descriptor_table_common_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

  typedef JobStateMsg_JobState JobState;
  static constexpr JobState START =
    JobStateMsg_JobState_START;
  static constexpr JobState STOP =
    JobStateMsg_JobState_STOP;
  static inline bool JobState_IsValid(int value) {
    return JobStateMsg_JobState_IsValid(value);
  }
  static constexpr JobState JobState_MIN =
    JobStateMsg_JobState_JobState_MIN;
  static constexpr JobState JobState_MAX =
    JobStateMsg_JobState_JobState_MAX;
  static constexpr int JobState_ARRAYSIZE =
    JobStateMsg_JobState_JobState_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  JobState_descriptor() {
    return JobStateMsg_JobState_descriptor();
  }
  template<typename T>
  static inline const std::string& JobState_Name(T enum_t_value) {
    static_assert(::std::is_same<T, JobState>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function JobState_Name.");
    return JobStateMsg_JobState_Name(enum_t_value);
  }
  static inline bool JobState_Parse(const std::string& name,
      JobState* value) {
    return JobStateMsg_JobState_Parse(name, value);
  }

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

  enum : int {
    kUIdFieldNumber = 2,
    kNameFieldNumber = 3,
    kMachineIdFieldNumber = 14,
    kJobInfoFieldNumber = 15,
    kJobIdFieldNumber = 1,
    kStartTimeFieldNumber = 4,
    kStopTimeFieldNumber = 5,
    kDeoxygenSecondFieldNumber = 6,
    kSpendSecondFieldNumber = 7,
    kMoldPosFieldNumber = 8,
    kPrintLayerIndexFieldNumber = 9,
    kIsFinishFieldNumber = 10,
    kIsContinueFieldNumber = 11,
    kIsInvalidFieldNumber = 12,
    kJobStateFieldNumber = 13,
  };
  // string uId = 2;
  void clear_uid();
  const std::string& uid() const;
  void set_uid(const std::string& value);
  void set_uid(std::string&& value);
  void set_uid(const char* value);
  void set_uid(const char* value, size_t size);
  std::string* mutable_uid();
  std::string* release_uid();
  void set_allocated_uid(std::string* uid);

  // string name = 3;
  void clear_name();
  const std::string& name() const;
  void set_name(const std::string& value);
  void set_name(std::string&& value);
  void set_name(const char* value);
  void set_name(const char* value, size_t size);
  std::string* mutable_name();
  std::string* release_name();
  void set_allocated_name(std::string* name);

  // string machineId = 14;
  void clear_machineid();
  const std::string& machineid() const;
  void set_machineid(const std::string& value);
  void set_machineid(std::string&& value);
  void set_machineid(const char* value);
  void set_machineid(const char* value, size_t size);
  std::string* mutable_machineid();
  std::string* release_machineid();
  void set_allocated_machineid(std::string* machineid);

  // .JobInfoMsg jobInfo = 15;
  bool has_jobinfo() const;
  void clear_jobinfo();
  const ::JobInfoMsg& jobinfo() const;
  ::JobInfoMsg* release_jobinfo();
  ::JobInfoMsg* mutable_jobinfo();
  void set_allocated_jobinfo(::JobInfoMsg* jobinfo);

  // uint64 jobId = 1;
  void clear_jobid();
  ::PROTOBUF_NAMESPACE_ID::uint64 jobid() const;
  void set_jobid(::PROTOBUF_NAMESPACE_ID::uint64 value);

  // int64 startTime = 4;
  void clear_starttime();
  ::PROTOBUF_NAMESPACE_ID::int64 starttime() const;
  void set_starttime(::PROTOBUF_NAMESPACE_ID::int64 value);

  // int64 stopTime = 5;
  void clear_stoptime();
  ::PROTOBUF_NAMESPACE_ID::int64 stoptime() const;
  void set_stoptime(::PROTOBUF_NAMESPACE_ID::int64 value);

  // uint32 deoxygenSecond = 6;
  void clear_deoxygensecond();
  ::PROTOBUF_NAMESPACE_ID::uint32 deoxygensecond() const;
  void set_deoxygensecond(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // uint32 spendSecond = 7;
  void clear_spendsecond();
  ::PROTOBUF_NAMESPACE_ID::uint32 spendsecond() const;
  void set_spendsecond(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // float moldPos = 8;
  void clear_moldpos();
  float moldpos() const;
  void set_moldpos(float value);

  // uint32 printLayerIndex = 9;
  void clear_printlayerindex();
  ::PROTOBUF_NAMESPACE_ID::uint32 printlayerindex() const;
  void set_printlayerindex(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // bool isFinish = 10;
  void clear_isfinish();
  bool isfinish() const;
  void set_isfinish(bool value);

  // bool isContinue = 11;
  void clear_iscontinue();
  bool iscontinue() const;
  void set_iscontinue(bool value);

  // bool isInvalid = 12;
  void clear_isinvalid();
  bool isinvalid() const;
  void set_isinvalid(bool value);

  // .JobStateMsg.JobState jobState = 13;
  void clear_jobstate();
  ::JobStateMsg_JobState jobstate() const;
  void set_jobstate(::JobStateMsg_JobState value);

  // @@protoc_insertion_point(class_scope:JobStateMsg)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr uid_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr machineid_;
  ::JobInfoMsg* jobinfo_;
  ::PROTOBUF_NAMESPACE_ID::uint64 jobid_;
  ::PROTOBUF_NAMESPACE_ID::int64 starttime_;
  ::PROTOBUF_NAMESPACE_ID::int64 stoptime_;
  ::PROTOBUF_NAMESPACE_ID::uint32 deoxygensecond_;
  ::PROTOBUF_NAMESPACE_ID::uint32 spendsecond_;
  float moldpos_;
  ::PROTOBUF_NAMESPACE_ID::uint32 printlayerindex_;
  bool isfinish_;
  bool iscontinue_;
  bool isinvalid_;
  int jobstate_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_common_2eproto;
};
// -------------------------------------------------------------------

class MachineMsg :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:MachineMsg) */ {
 public:
  MachineMsg();
  virtual ~MachineMsg();

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

  inline MachineMsg& operator=(const MachineMsg& from) {
    CopyFrom(from);
    return *this;
  }
  inline MachineMsg& operator=(MachineMsg&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const MachineMsg& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const MachineMsg* internal_default_instance() {
    return reinterpret_cast<const MachineMsg*>(
               &_MachineMsg_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

  friend void swap(MachineMsg& a, MachineMsg& b) {
    a.Swap(&b);
  }
  inline void Swap(MachineMsg* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline MachineMsg* New() const final {
    return CreateMaybeMessage<MachineMsg>(nullptr);
  }

  MachineMsg* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<MachineMsg>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const MachineMsg& from);
  void MergeFrom(const MachineMsg& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(MachineMsg* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "MachineMsg";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_common_2eproto);
    return ::descriptor_table_common_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

  typedef MachineMsg_MachineType MachineType;
  static constexpr MachineType HBD_100 =
    MachineMsg_MachineType_HBD_100;
  static constexpr MachineType HBD_280 =
    MachineMsg_MachineType_HBD_280;
  static constexpr MachineType HBD_80 =
    MachineMsg_MachineType_HBD_80;
  static constexpr MachineType HBD_400 =
    MachineMsg_MachineType_HBD_400;
  static inline bool MachineType_IsValid(int value) {
    return MachineMsg_MachineType_IsValid(value);
  }
  static constexpr MachineType MachineType_MIN =
    MachineMsg_MachineType_MachineType_MIN;
  static constexpr MachineType MachineType_MAX =
    MachineMsg_MachineType_MachineType_MAX;
  static constexpr int MachineType_ARRAYSIZE =
    MachineMsg_MachineType_MachineType_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  MachineType_descriptor() {
    return MachineMsg_MachineType_descriptor();
  }
  template<typename T>
  static inline const std::string& MachineType_Name(T enum_t_value) {
    static_assert(::std::is_same<T, MachineType>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function MachineType_Name.");
    return MachineMsg_MachineType_Name(enum_t_value);
  }
  static inline bool MachineType_Parse(const std::string& name,
      MachineType* value) {
    return MachineMsg_MachineType_Parse(name, value);
  }

  typedef MachineMsg_PurifierType PurifierType;
  static constexpr PurifierType HBD_PURIFIER_1 =
    MachineMsg_PurifierType_HBD_PURIFIER_1;
  static constexpr PurifierType XT =
    MachineMsg_PurifierType_XT;
  static constexpr PurifierType HBD_PURIFIER_2 =
    MachineMsg_PurifierType_HBD_PURIFIER_2;
  static inline bool PurifierType_IsValid(int value) {
    return MachineMsg_PurifierType_IsValid(value);
  }
  static constexpr PurifierType PurifierType_MIN =
    MachineMsg_PurifierType_PurifierType_MIN;
  static constexpr PurifierType PurifierType_MAX =
    MachineMsg_PurifierType_PurifierType_MAX;
  static constexpr int PurifierType_ARRAYSIZE =
    MachineMsg_PurifierType_PurifierType_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  PurifierType_descriptor() {
    return MachineMsg_PurifierType_descriptor();
  }
  template<typename T>
  static inline const std::string& PurifierType_Name(T enum_t_value) {
    static_assert(::std::is_same<T, PurifierType>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function PurifierType_Name.");
    return MachineMsg_PurifierType_Name(enum_t_value);
  }
  static inline bool PurifierType_Parse(const std::string& name,
      PurifierType* value) {
    return MachineMsg_PurifierType_Parse(name, value);
  }

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

  enum : int {
    kMachineIdFieldNumber = 1,
    kPasswordFieldNumber = 8,
    kNameFieldNumber = 9,
    kLocationFieldNumber = 10,
    kMachineTypeFieldNumber = 2,
    kPurifierTypeFieldNumber = 3,
    kLastStartTimeFieldNumber = 4,
    kLastShutdownTimeFieldNumber = 5,
    kLanguageFieldNumber = 6,
    kIsOnlineFieldNumber = 7,
  };
  // string machineId = 1;
  void clear_machineid();
  const std::string& machineid() const;
  void set_machineid(const std::string& value);
  void set_machineid(std::string&& value);
  void set_machineid(const char* value);
  void set_machineid(const char* value, size_t size);
  std::string* mutable_machineid();
  std::string* release_machineid();
  void set_allocated_machineid(std::string* machineid);

  // string password = 8;
  void clear_password();
  const std::string& password() const;
  void set_password(const std::string& value);
  void set_password(std::string&& value);
  void set_password(const char* value);
  void set_password(const char* value, size_t size);
  std::string* mutable_password();
  std::string* release_password();
  void set_allocated_password(std::string* password);

  // string name = 9;
  void clear_name();
  const std::string& name() const;
  void set_name(const std::string& value);
  void set_name(std::string&& value);
  void set_name(const char* value);
  void set_name(const char* value, size_t size);
  std::string* mutable_name();
  std::string* release_name();
  void set_allocated_name(std::string* name);

  // string location = 10;
  void clear_location();
  const std::string& location() const;
  void set_location(const std::string& value);
  void set_location(std::string&& value);
  void set_location(const char* value);
  void set_location(const char* value, size_t size);
  std::string* mutable_location();
  std::string* release_location();
  void set_allocated_location(std::string* location);

  // .MachineMsg.MachineType machineType = 2;
  void clear_machinetype();
  ::MachineMsg_MachineType machinetype() const;
  void set_machinetype(::MachineMsg_MachineType value);

  // .MachineMsg.PurifierType purifierType = 3;
  void clear_purifiertype();
  ::MachineMsg_PurifierType purifiertype() const;
  void set_purifiertype(::MachineMsg_PurifierType value);

  // int64 lastStartTime = 4;
  void clear_laststarttime();
  ::PROTOBUF_NAMESPACE_ID::int64 laststarttime() const;
  void set_laststarttime(::PROTOBUF_NAMESPACE_ID::int64 value);

  // int64 lastShutdownTime = 5;
  void clear_lastshutdowntime();
  ::PROTOBUF_NAMESPACE_ID::int64 lastshutdowntime() const;
  void set_lastshutdowntime(::PROTOBUF_NAMESPACE_ID::int64 value);

  // int32 language = 6;
  void clear_language();
  ::PROTOBUF_NAMESPACE_ID::int32 language() const;
  void set_language(::PROTOBUF_NAMESPACE_ID::int32 value);

  // bool isOnline = 7;
  void clear_isonline();
  bool isonline() const;
  void set_isonline(bool value);

  // @@protoc_insertion_point(class_scope:MachineMsg)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr machineid_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr password_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr location_;
  int machinetype_;
  int purifiertype_;
  ::PROTOBUF_NAMESPACE_ID::int64 laststarttime_;
  ::PROTOBUF_NAMESPACE_ID::int64 lastshutdowntime_;
  ::PROTOBUF_NAMESPACE_ID::int32 language_;
  bool isonline_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_common_2eproto;
};
// -------------------------------------------------------------------

class ErrorMsg :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:ErrorMsg) */ {
 public:
  ErrorMsg();
  virtual ~ErrorMsg();

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

  inline ErrorMsg& operator=(const ErrorMsg& from) {
    CopyFrom(from);
    return *this;
  }
  inline ErrorMsg& operator=(ErrorMsg&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const ErrorMsg& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const ErrorMsg* internal_default_instance() {
    return reinterpret_cast<const ErrorMsg*>(
               &_ErrorMsg_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;

  friend void swap(ErrorMsg& a, ErrorMsg& b) {
    a.Swap(&b);
  }
  inline void Swap(ErrorMsg* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline ErrorMsg* New() const final {
    return CreateMaybeMessage<ErrorMsg>(nullptr);
  }

  ErrorMsg* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ErrorMsg>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const ErrorMsg& from);
  void MergeFrom(const ErrorMsg& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ErrorMsg* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "ErrorMsg";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_common_2eproto);
    return ::descriptor_table_common_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

  typedef ErrorMsg_ErrorType ErrorType;
  static constexpr ErrorType STOP =
    ErrorMsg_ErrorType_STOP;
  static constexpr ErrorType PAUSE =
    ErrorMsg_ErrorType_PAUSE;
  static inline bool ErrorType_IsValid(int value) {
    return ErrorMsg_ErrorType_IsValid(value);
  }
  static constexpr ErrorType ErrorType_MIN =
    ErrorMsg_ErrorType_ErrorType_MIN;
  static constexpr ErrorType ErrorType_MAX =
    ErrorMsg_ErrorType_ErrorType_MAX;
  static constexpr int ErrorType_ARRAYSIZE =
    ErrorMsg_ErrorType_ErrorType_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  ErrorType_descriptor() {
    return ErrorMsg_ErrorType_descriptor();
  }
  template<typename T>
  static inline const std::string& ErrorType_Name(T enum_t_value) {
    static_assert(::std::is_same<T, ErrorType>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function ErrorType_Name.");
    return ErrorMsg_ErrorType_Name(enum_t_value);
  }
  static inline bool ErrorType_Parse(const std::string& name,
      ErrorType* value) {
    return ErrorMsg_ErrorType_Parse(name, value);
  }

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

  enum : int {
    kErrorMsgFieldNumber = 2,
    kMachineIdFieldNumber = 4,
    kOccurTimeFieldNumber = 3,
    kErrorTypeFieldNumber = 1,
  };
  // string errorMsg = 2;
  void clear_errormsg();
  const std::string& errormsg() const;
  void set_errormsg(const std::string& value);
  void set_errormsg(std::string&& value);
  void set_errormsg(const char* value);
  void set_errormsg(const char* value, size_t size);
  std::string* mutable_errormsg();
  std::string* release_errormsg();
  void set_allocated_errormsg(std::string* errormsg);

  // string machineId = 4;
  void clear_machineid();
  const std::string& machineid() const;
  void set_machineid(const std::string& value);
  void set_machineid(std::string&& value);
  void set_machineid(const char* value);
  void set_machineid(const char* value, size_t size);
  std::string* mutable_machineid();
  std::string* release_machineid();
  void set_allocated_machineid(std::string* machineid);

  // int64 occurTime = 3;
  void clear_occurtime();
  ::PROTOBUF_NAMESPACE_ID::int64 occurtime() const;
  void set_occurtime(::PROTOBUF_NAMESPACE_ID::int64 value);

  // .ErrorMsg.ErrorType errorType = 1;
  void clear_errortype();
  ::ErrorMsg_ErrorType errortype() const;
  void set_errortype(::ErrorMsg_ErrorType value);

  // @@protoc_insertion_point(class_scope:ErrorMsg)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr errormsg_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr machineid_;
  ::PROTOBUF_NAMESPACE_ID::int64 occurtime_;
  int errortype_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_common_2eproto;
};
// -------------------------------------------------------------------

class ParameterMsg :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:ParameterMsg) */ {
 public:
  ParameterMsg();
  virtual ~ParameterMsg();

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

  inline ParameterMsg& operator=(const ParameterMsg& from) {
    CopyFrom(from);
    return *this;
  }
  inline ParameterMsg& operator=(ParameterMsg&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const ParameterMsg& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const ParameterMsg* internal_default_instance() {
    return reinterpret_cast<const ParameterMsg*>(
               &_ParameterMsg_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    5;

  friend void swap(ParameterMsg& a, ParameterMsg& b) {
    a.Swap(&b);
  }
  inline void Swap(ParameterMsg* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline ParameterMsg* New() const final {
    return CreateMaybeMessage<ParameterMsg>(nullptr);
  }

  ParameterMsg* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ParameterMsg>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const ParameterMsg& from);
  void MergeFrom(const ParameterMsg& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ParameterMsg* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "ParameterMsg";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_common_2eproto);
    return ::descriptor_table_common_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kTypeFieldNumber = 1,
    kLaserSpeedFieldNumber = 2,
    kLaserPowerFieldNumber = 3,
    kLaserDiameterFieldNumber = 4,
  };
  // string type = 1;
  void clear_type();
  const std::string& type() const;
  void set_type(const std::string& value);
  void set_type(std::string&& value);
  void set_type(const char* value);
  void set_type(const char* value, size_t size);
  std::string* mutable_type();
  std::string* release_type();
  void set_allocated_type(std::string* type);

  // float laserSpeed = 2;
  void clear_laserspeed();
  float laserspeed() const;
  void set_laserspeed(float value);

  // float laserPower = 3;
  void clear_laserpower();
  float laserpower() const;
  void set_laserpower(float value);

  // float laserDiameter = 4;
  void clear_laserdiameter();
  float laserdiameter() const;
  void set_laserdiameter(float value);

  // @@protoc_insertion_point(class_scope:ParameterMsg)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr type_;
  float laserspeed_;
  float laserpower_;
  float laserdiameter_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_common_2eproto;
};
// -------------------------------------------------------------------

class PartMsg :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:PartMsg) */ {
 public:
  PartMsg();
  virtual ~PartMsg();

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

  inline PartMsg& operator=(const PartMsg& from) {
    CopyFrom(from);
    return *this;
  }
  inline PartMsg& operator=(PartMsg&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const PartMsg& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const PartMsg* internal_default_instance() {
    return reinterpret_cast<const PartMsg*>(
               &_PartMsg_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    6;

  friend void swap(PartMsg& a, PartMsg& b) {
    a.Swap(&b);
  }
  inline void Swap(PartMsg* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline PartMsg* New() const final {
    return CreateMaybeMessage<PartMsg>(nullptr);
  }

  PartMsg* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<PartMsg>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const PartMsg& from);
  void MergeFrom(const PartMsg& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(PartMsg* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "PartMsg";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_common_2eproto);
    return ::descriptor_table_common_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kParamFieldNumber = 2,
    kNameFieldNumber = 1,
  };
  // repeated .ParameterMsg param = 2;
  int param_size() const;
  void clear_param();
  ::ParameterMsg* mutable_param(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::ParameterMsg >*
      mutable_param();
  const ::ParameterMsg& param(int index) const;
  ::ParameterMsg* add_param();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::ParameterMsg >&
      param() const;

  // string name = 1;
  void clear_name();
  const std::string& name() const;
  void set_name(const std::string& value);
  void set_name(std::string&& value);
  void set_name(const char* value);
  void set_name(const char* value, size_t size);
  std::string* mutable_name();
  std::string* release_name();
  void set_allocated_name(std::string* name);

  // @@protoc_insertion_point(class_scope:PartMsg)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::ParameterMsg > param_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_common_2eproto;
};
// -------------------------------------------------------------------

class JobMsg :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:JobMsg) */ {
 public:
  JobMsg();
  virtual ~JobMsg();

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

  inline JobMsg& operator=(const JobMsg& from) {
    CopyFrom(from);
    return *this;
  }
  inline JobMsg& operator=(JobMsg&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const JobMsg& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const JobMsg* internal_default_instance() {
    return reinterpret_cast<const JobMsg*>(
               &_JobMsg_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    7;

  friend void swap(JobMsg& a, JobMsg& b) {
    a.Swap(&b);
  }
  inline void Swap(JobMsg* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline JobMsg* New() const final {
    return CreateMaybeMessage<JobMsg>(nullptr);
  }

  JobMsg* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<JobMsg>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const JobMsg& from);
  void MergeFrom(const JobMsg& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(JobMsg* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "JobMsg";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_common_2eproto);
    return ::descriptor_table_common_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kPartMsgFieldNumber = 2,
    kMachineIdFieldNumber = 3,
    kJobInfoMsgFieldNumber = 1,
  };
  // repeated .PartMsg partMsg = 2;
  int partmsg_size() const;
  void clear_partmsg();
  ::PartMsg* mutable_partmsg(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PartMsg >*
      mutable_partmsg();
  const ::PartMsg& partmsg(int index) const;
  ::PartMsg* add_partmsg();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PartMsg >&
      partmsg() const;

  // string machineId = 3;
  void clear_machineid();
  const std::string& machineid() const;
  void set_machineid(const std::string& value);
  void set_machineid(std::string&& value);
  void set_machineid(const char* value);
  void set_machineid(const char* value, size_t size);
  std::string* mutable_machineid();
  std::string* release_machineid();
  void set_allocated_machineid(std::string* machineid);

  // .JobInfoMsg jobInfoMsg = 1;
  bool has_jobinfomsg() const;
  void clear_jobinfomsg();
  const ::JobInfoMsg& jobinfomsg() const;
  ::JobInfoMsg* release_jobinfomsg();
  ::JobInfoMsg* mutable_jobinfomsg();
  void set_allocated_jobinfomsg(::JobInfoMsg* jobinfomsg);

  // @@protoc_insertion_point(class_scope:JobMsg)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PartMsg > partmsg_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr machineid_;
  ::JobInfoMsg* jobinfomsg_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_common_2eproto;
};
// -------------------------------------------------------------------

class LayerDataRespMsg :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:LayerDataRespMsg) */ {
 public:
  LayerDataRespMsg();
  virtual ~LayerDataRespMsg();

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

  inline LayerDataRespMsg& operator=(const LayerDataRespMsg& from) {
    CopyFrom(from);
    return *this;
  }
  inline LayerDataRespMsg& operator=(LayerDataRespMsg&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const LayerDataRespMsg& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const LayerDataRespMsg* internal_default_instance() {
    return reinterpret_cast<const LayerDataRespMsg*>(
               &_LayerDataRespMsg_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    8;

  friend void swap(LayerDataRespMsg& a, LayerDataRespMsg& b) {
    a.Swap(&b);
  }
  inline void Swap(LayerDataRespMsg* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline LayerDataRespMsg* New() const final {
    return CreateMaybeMessage<LayerDataRespMsg>(nullptr);
  }

  LayerDataRespMsg* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<LayerDataRespMsg>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const LayerDataRespMsg& from);
  void MergeFrom(const LayerDataRespMsg& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(LayerDataRespMsg* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "LayerDataRespMsg";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_common_2eproto);
    return ::descriptor_table_common_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kDataFieldNumber = 6,
    kMachineIdFieldNumber = 1,
    kDatasFieldNumber = 7,
    kParamTypeFieldNumber = 8,
    kTypeFieldNumber = 2,
    kPartIdFieldNumber = 3,
    kTotalFieldNumber = 4,
    kIndexFieldNumber = 5,
  };
  // repeated float data = 6;
  int data_size() const;
  void clear_data();
  float data(int index) const;
  void set_data(int index, float value);
  void add_data(float value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      data() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      mutable_data();

  // string machineId = 1;
  void clear_machineid();
  const std::string& machineid() const;
  void set_machineid(const std::string& value);
  void set_machineid(std::string&& value);
  void set_machineid(const char* value);
  void set_machineid(const char* value, size_t size);
  std::string* mutable_machineid();
  std::string* release_machineid();
  void set_allocated_machineid(std::string* machineid);

  // bytes datas = 7;
  void clear_datas();
  const std::string& datas() const;
  void set_datas(const std::string& value);
  void set_datas(std::string&& value);
  void set_datas(const char* value);
  void set_datas(const void* value, size_t size);
  std::string* mutable_datas();
  std::string* release_datas();
  void set_allocated_datas(std::string* datas);

  // string paramType = 8;
  void clear_paramtype();
  const std::string& paramtype() const;
  void set_paramtype(const std::string& value);
  void set_paramtype(std::string&& value);
  void set_paramtype(const char* value);
  void set_paramtype(const char* value, size_t size);
  std::string* mutable_paramtype();
  std::string* release_paramtype();
  void set_allocated_paramtype(std::string* paramtype);

  // int32 type = 2;
  void clear_type();
  ::PROTOBUF_NAMESPACE_ID::int32 type() const;
  void set_type(::PROTOBUF_NAMESPACE_ID::int32 value);

  // int32 partId = 3;
  void clear_partid();
  ::PROTOBUF_NAMESPACE_ID::int32 partid() const;
  void set_partid(::PROTOBUF_NAMESPACE_ID::int32 value);

  // uint32 total = 4;
  void clear_total();
  ::PROTOBUF_NAMESPACE_ID::uint32 total() const;
  void set_total(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // uint32 index = 5;
  void clear_index();
  ::PROTOBUF_NAMESPACE_ID::uint32 index() const;
  void set_index(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // @@protoc_insertion_point(class_scope:LayerDataRespMsg)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > data_;
  mutable std::atomic<int> _data_cached_byte_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr machineid_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr datas_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr paramtype_;
  ::PROTOBUF_NAMESPACE_ID::int32 type_;
  ::PROTOBUF_NAMESPACE_ID::int32 partid_;
  ::PROTOBUF_NAMESPACE_ID::uint32 total_;
  ::PROTOBUF_NAMESPACE_ID::uint32 index_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_common_2eproto;
};
// -------------------------------------------------------------------

class DataBlockMsg :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:DataBlockMsg) */ {
 public:
  DataBlockMsg();
  virtual ~DataBlockMsg();

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

  inline DataBlockMsg& operator=(const DataBlockMsg& from) {
    CopyFrom(from);
    return *this;
  }
  inline DataBlockMsg& operator=(DataBlockMsg&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const DataBlockMsg& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const DataBlockMsg* internal_default_instance() {
    return reinterpret_cast<const DataBlockMsg*>(
               &_DataBlockMsg_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    9;

  friend void swap(DataBlockMsg& a, DataBlockMsg& b) {
    a.Swap(&b);
  }
  inline void Swap(DataBlockMsg* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline DataBlockMsg* New() const final {
    return CreateMaybeMessage<DataBlockMsg>(nullptr);
  }

  DataBlockMsg* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<DataBlockMsg>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const DataBlockMsg& from);
  void MergeFrom(const DataBlockMsg& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(DataBlockMsg* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "DataBlockMsg";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_common_2eproto);
    return ::descriptor_table_common_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kDataFieldNumber = 2,
    kTypeFieldNumber = 1,
  };
  // repeated float data = 2;
  int data_size() const;
  void clear_data();
  float data(int index) const;
  void set_data(int index, float value);
  void add_data(float value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      data() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      mutable_data();

  // int32 type = 1;
  void clear_type();
  ::PROTOBUF_NAMESPACE_ID::int32 type() const;
  void set_type(::PROTOBUF_NAMESPACE_ID::int32 value);

  // @@protoc_insertion_point(class_scope:DataBlockMsg)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > data_;
  mutable std::atomic<int> _data_cached_byte_size_;
  ::PROTOBUF_NAMESPACE_ID::int32 type_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_common_2eproto;
};
// -------------------------------------------------------------------

class LayerDataBlockMsg :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:LayerDataBlockMsg) */ {
 public:
  LayerDataBlockMsg();
  virtual ~LayerDataBlockMsg();

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

  inline LayerDataBlockMsg& operator=(const LayerDataBlockMsg& from) {
    CopyFrom(from);
    return *this;
  }
  inline LayerDataBlockMsg& operator=(LayerDataBlockMsg&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const LayerDataBlockMsg& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const LayerDataBlockMsg* internal_default_instance() {
    return reinterpret_cast<const LayerDataBlockMsg*>(
               &_LayerDataBlockMsg_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    10;

  friend void swap(LayerDataBlockMsg& a, LayerDataBlockMsg& b) {
    a.Swap(&b);
  }
  inline void Swap(LayerDataBlockMsg* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline LayerDataBlockMsg* New() const final {
    return CreateMaybeMessage<LayerDataBlockMsg>(nullptr);
  }

  LayerDataBlockMsg* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<LayerDataBlockMsg>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const LayerDataBlockMsg& from);
  void MergeFrom(const LayerDataBlockMsg& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(LayerDataBlockMsg* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "LayerDataBlockMsg";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_common_2eproto);
    return ::descriptor_table_common_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kDataBlocksFieldNumber = 7,
    kMachineIdFieldNumber = 1,
    kJobNameFieldNumber = 2,
    kJobUidFieldNumber = 3,
    kLayerCountFieldNumber = 4,
    kThicknessFieldNumber = 5,
    kLayerIndexFieldNumber = 6,
  };
  // repeated .DataBlockMsg dataBlocks = 7;
  int datablocks_size() const;
  void clear_datablocks();
  ::DataBlockMsg* mutable_datablocks(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::DataBlockMsg >*
      mutable_datablocks();
  const ::DataBlockMsg& datablocks(int index) const;
  ::DataBlockMsg* add_datablocks();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::DataBlockMsg >&
      datablocks() const;

  // string machineId = 1;
  void clear_machineid();
  const std::string& machineid() const;
  void set_machineid(const std::string& value);
  void set_machineid(std::string&& value);
  void set_machineid(const char* value);
  void set_machineid(const char* value, size_t size);
  std::string* mutable_machineid();
  std::string* release_machineid();
  void set_allocated_machineid(std::string* machineid);

  // string jobName = 2;
  void clear_jobname();
  const std::string& jobname() const;
  void set_jobname(const std::string& value);
  void set_jobname(std::string&& value);
  void set_jobname(const char* value);
  void set_jobname(const char* value, size_t size);
  std::string* mutable_jobname();
  std::string* release_jobname();
  void set_allocated_jobname(std::string* jobname);

  // string jobUid = 3;
  void clear_jobuid();
  const std::string& jobuid() const;
  void set_jobuid(const std::string& value);
  void set_jobuid(std::string&& value);
  void set_jobuid(const char* value);
  void set_jobuid(const char* value, size_t size);
  std::string* mutable_jobuid();
  std::string* release_jobuid();
  void set_allocated_jobuid(std::string* jobuid);

  // uint32 layerCount = 4;
  void clear_layercount();
  ::PROTOBUF_NAMESPACE_ID::uint32 layercount() const;
  void set_layercount(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // float thickness = 5;
  void clear_thickness();
  float thickness() const;
  void set_thickness(float value);

  // uint32 layerIndex = 6;
  void clear_layerindex();
  ::PROTOBUF_NAMESPACE_ID::uint32 layerindex() const;
  void set_layerindex(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // @@protoc_insertion_point(class_scope:LayerDataBlockMsg)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::DataBlockMsg > datablocks_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr machineid_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr jobname_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr jobuid_;
  ::PROTOBUF_NAMESPACE_ID::uint32 layercount_;
  float thickness_;
  ::PROTOBUF_NAMESPACE_ID::uint32 layerindex_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_common_2eproto;
};
// -------------------------------------------------------------------

class JobParamMsg :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:JobParamMsg) */ {
 public:
  JobParamMsg();
  virtual ~JobParamMsg();

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

  inline JobParamMsg& operator=(const JobParamMsg& from) {
    CopyFrom(from);
    return *this;
  }
  inline JobParamMsg& operator=(JobParamMsg&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const JobParamMsg& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const JobParamMsg* internal_default_instance() {
    return reinterpret_cast<const JobParamMsg*>(
               &_JobParamMsg_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    11;

  friend void swap(JobParamMsg& a, JobParamMsg& b) {
    a.Swap(&b);
  }
  inline void Swap(JobParamMsg* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline JobParamMsg* New() const final {
    return CreateMaybeMessage<JobParamMsg>(nullptr);
  }

  JobParamMsg* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<JobParamMsg>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const JobParamMsg& from);
  void MergeFrom(const JobParamMsg& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(JobParamMsg* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "JobParamMsg";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_common_2eproto);
    return ::descriptor_table_common_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kPartsFieldNumber = 6,
    kMachineIdFieldNumber = 1,
    kJobNameFieldNumber = 2,
    kJobUidFieldNumber = 3,
    kLayerCountFieldNumber = 4,
    kThicknessFieldNumber = 5,
  };
  // repeated .PartMsg parts = 6;
  int parts_size() const;
  void clear_parts();
  ::PartMsg* mutable_parts(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PartMsg >*
      mutable_parts();
  const ::PartMsg& parts(int index) const;
  ::PartMsg* add_parts();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PartMsg >&
      parts() const;

  // string machineId = 1;
  void clear_machineid();
  const std::string& machineid() const;
  void set_machineid(const std::string& value);
  void set_machineid(std::string&& value);
  void set_machineid(const char* value);
  void set_machineid(const char* value, size_t size);
  std::string* mutable_machineid();
  std::string* release_machineid();
  void set_allocated_machineid(std::string* machineid);

  // string jobName = 2;
  void clear_jobname();
  const std::string& jobname() const;
  void set_jobname(const std::string& value);
  void set_jobname(std::string&& value);
  void set_jobname(const char* value);
  void set_jobname(const char* value, size_t size);
  std::string* mutable_jobname();
  std::string* release_jobname();
  void set_allocated_jobname(std::string* jobname);

  // string jobUid = 3;
  void clear_jobuid();
  const std::string& jobuid() const;
  void set_jobuid(const std::string& value);
  void set_jobuid(std::string&& value);
  void set_jobuid(const char* value);
  void set_jobuid(const char* value, size_t size);
  std::string* mutable_jobuid();
  std::string* release_jobuid();
  void set_allocated_jobuid(std::string* jobuid);

  // uint32 layerCount = 4;
  void clear_layercount();
  ::PROTOBUF_NAMESPACE_ID::uint32 layercount() const;
  void set_layercount(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // float thickness = 5;
  void clear_thickness();
  float thickness() const;
  void set_thickness(float value);

  // @@protoc_insertion_point(class_scope:JobParamMsg)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PartMsg > parts_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr machineid_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr jobname_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr jobuid_;
  ::PROTOBUF_NAMESPACE_ID::uint32 layercount_;
  float thickness_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_common_2eproto;
};
// -------------------------------------------------------------------

class LayerDataReqMsg :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:LayerDataReqMsg) */ {
 public:
  LayerDataReqMsg();
  virtual ~LayerDataReqMsg();

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

  inline LayerDataReqMsg& operator=(const LayerDataReqMsg& from) {
    CopyFrom(from);
    return *this;
  }
  inline LayerDataReqMsg& operator=(LayerDataReqMsg&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const LayerDataReqMsg& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const LayerDataReqMsg* internal_default_instance() {
    return reinterpret_cast<const LayerDataReqMsg*>(
               &_LayerDataReqMsg_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    12;

  friend void swap(LayerDataReqMsg& a, LayerDataReqMsg& b) {
    a.Swap(&b);
  }
  inline void Swap(LayerDataReqMsg* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline LayerDataReqMsg* New() const final {
    return CreateMaybeMessage<LayerDataReqMsg>(nullptr);
  }

  LayerDataReqMsg* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<LayerDataReqMsg>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const LayerDataReqMsg& from);
  void MergeFrom(const LayerDataReqMsg& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(LayerDataReqMsg* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "LayerDataReqMsg";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_common_2eproto);
    return ::descriptor_table_common_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kMachineIdFieldNumber = 1,
    kLayerIndexFieldNumber = 2,
  };
  // string machineId = 1;
  void clear_machineid();
  const std::string& machineid() const;
  void set_machineid(const std::string& value);
  void set_machineid(std::string&& value);
  void set_machineid(const char* value);
  void set_machineid(const char* value, size_t size);
  std::string* mutable_machineid();
  std::string* release_machineid();
  void set_allocated_machineid(std::string* machineid);

  // uint32 layerIndex = 2;
  void clear_layerindex();
  ::PROTOBUF_NAMESPACE_ID::uint32 layerindex() const;
  void set_layerindex(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // @@protoc_insertion_point(class_scope:LayerDataReqMsg)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr machineid_;
  ::PROTOBUF_NAMESPACE_ID::uint32 layerindex_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_common_2eproto;
};
// -------------------------------------------------------------------

class ResponseState :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:ResponseState) */ {
 public:
  ResponseState();
  virtual ~ResponseState();

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

  inline ResponseState& operator=(const ResponseState& from) {
    CopyFrom(from);
    return *this;
  }
  inline ResponseState& operator=(ResponseState&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const ResponseState& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const ResponseState* internal_default_instance() {
    return reinterpret_cast<const ResponseState*>(
               &_ResponseState_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    13;

  friend void swap(ResponseState& a, ResponseState& b) {
    a.Swap(&b);
  }
  inline void Swap(ResponseState* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline ResponseState* New() const final {
    return CreateMaybeMessage<ResponseState>(nullptr);
  }

  ResponseState* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ResponseState>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const ResponseState& from);
  void MergeFrom(const ResponseState& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ResponseState* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "ResponseState";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_common_2eproto);
    return ::descriptor_table_common_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kStateMsgFieldNumber = 1,
  };
  // repeated .StateMsg stateMsg = 1;
  int statemsg_size() const;
  void clear_statemsg();
  ::StateMsg* mutable_statemsg(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::StateMsg >*
      mutable_statemsg();
  const ::StateMsg& statemsg(int index) const;
  ::StateMsg* add_statemsg();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::StateMsg >&
      statemsg() const;

  // @@protoc_insertion_point(class_scope:ResponseState)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::StateMsg > statemsg_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_common_2eproto;
};
// -------------------------------------------------------------------

class CameraDataMsg :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CameraDataMsg) */ {
 public:
  CameraDataMsg();
  virtual ~CameraDataMsg();

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

  inline CameraDataMsg& operator=(const CameraDataMsg& from) {
    CopyFrom(from);
    return *this;
  }
  inline CameraDataMsg& operator=(CameraDataMsg&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const CameraDataMsg& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const CameraDataMsg* internal_default_instance() {
    return reinterpret_cast<const CameraDataMsg*>(
               &_CameraDataMsg_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    14;

  friend void swap(CameraDataMsg& a, CameraDataMsg& b) {
    a.Swap(&b);
  }
  inline void Swap(CameraDataMsg* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline CameraDataMsg* New() const final {
    return CreateMaybeMessage<CameraDataMsg>(nullptr);
  }

  CameraDataMsg* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<CameraDataMsg>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const CameraDataMsg& from);
  void MergeFrom(const CameraDataMsg& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CameraDataMsg* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CameraDataMsg";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_common_2eproto);
    return ::descriptor_table_common_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kMachineIdFieldNumber = 1,
    kDatasFieldNumber = 4,
    kWidthFieldNumber = 2,
    kHeightFieldNumber = 3,
  };
  // string machineId = 1;
  void clear_machineid();
  const std::string& machineid() const;
  void set_machineid(const std::string& value);
  void set_machineid(std::string&& value);
  void set_machineid(const char* value);
  void set_machineid(const char* value, size_t size);
  std::string* mutable_machineid();
  std::string* release_machineid();
  void set_allocated_machineid(std::string* machineid);

  // bytes datas = 4;
  void clear_datas();
  const std::string& datas() const;
  void set_datas(const std::string& value);
  void set_datas(std::string&& value);
  void set_datas(const char* value);
  void set_datas(const void* value, size_t size);
  std::string* mutable_datas();
  std::string* release_datas();
  void set_allocated_datas(std::string* datas);

  // uint32 width = 2;
  void clear_width();
  ::PROTOBUF_NAMESPACE_ID::uint32 width() const;
  void set_width(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // uint32 height = 3;
  void clear_height();
  ::PROTOBUF_NAMESPACE_ID::uint32 height() const;
  void set_height(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // @@protoc_insertion_point(class_scope:CameraDataMsg)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr machineid_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr datas_;
  ::PROTOBUF_NAMESPACE_ID::uint32 width_;
  ::PROTOBUF_NAMESPACE_ID::uint32 height_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_common_2eproto;
};
// -------------------------------------------------------------------

class AlarmMsg :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:AlarmMsg) */ {
 public:
  AlarmMsg();
  virtual ~AlarmMsg();

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

  inline AlarmMsg& operator=(const AlarmMsg& from) {
    CopyFrom(from);
    return *this;
  }
  inline AlarmMsg& operator=(AlarmMsg&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const AlarmMsg& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const AlarmMsg* internal_default_instance() {
    return reinterpret_cast<const AlarmMsg*>(
               &_AlarmMsg_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    15;

  friend void swap(AlarmMsg& a, AlarmMsg& b) {
    a.Swap(&b);
  }
  inline void Swap(AlarmMsg* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline AlarmMsg* New() const final {
    return CreateMaybeMessage<AlarmMsg>(nullptr);
  }

  AlarmMsg* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<AlarmMsg>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const AlarmMsg& from);
  void MergeFrom(const AlarmMsg& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(AlarmMsg* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "AlarmMsg";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_common_2eproto);
    return ::descriptor_table_common_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kTimeFieldNumber = 1,
    kTaskFieldNumber = 2,
    kTypeFieldNumber = 3,
    kDetailFieldNumber = 4,
  };
  // string time = 1;
  void clear_time();
  const std::string& time() const;
  void set_time(const std::string& value);
  void set_time(std::string&& value);
  void set_time(const char* value);
  void set_time(const char* value, size_t size);
  std::string* mutable_time();
  std::string* release_time();
  void set_allocated_time(std::string* time);

  // string task = 2;
  void clear_task();
  const std::string& task() const;
  void set_task(const std::string& value);
  void set_task(std::string&& value);
  void set_task(const char* value);
  void set_task(const char* value, size_t size);
  std::string* mutable_task();
  std::string* release_task();
  void set_allocated_task(std::string* task);

  // string type = 3;
  void clear_type();
  const std::string& type() const;
  void set_type(const std::string& value);
  void set_type(std::string&& value);
  void set_type(const char* value);
  void set_type(const char* value, size_t size);
  std::string* mutable_type();
  std::string* release_type();
  void set_allocated_type(std::string* type);

  // string detail = 4;
  void clear_detail();
  const std::string& detail() const;
  void set_detail(const std::string& value);
  void set_detail(std::string&& value);
  void set_detail(const char* value);
  void set_detail(const char* value, size_t size);
  std::string* mutable_detail();
  std::string* release_detail();
  void set_allocated_detail(std::string* detail);

  // @@protoc_insertion_point(class_scope:AlarmMsg)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr time_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr task_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr type_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr detail_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_common_2eproto;
};
// -------------------------------------------------------------------

class AlarmsMsg :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:AlarmsMsg) */ {
 public:
  AlarmsMsg();
  virtual ~AlarmsMsg();

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

  inline AlarmsMsg& operator=(const AlarmsMsg& from) {
    CopyFrom(from);
    return *this;
  }
  inline AlarmsMsg& operator=(AlarmsMsg&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const AlarmsMsg& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const AlarmsMsg* internal_default_instance() {
    return reinterpret_cast<const AlarmsMsg*>(
               &_AlarmsMsg_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    16;

  friend void swap(AlarmsMsg& a, AlarmsMsg& b) {
    a.Swap(&b);
  }
  inline void Swap(AlarmsMsg* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline AlarmsMsg* New() const final {
    return CreateMaybeMessage<AlarmsMsg>(nullptr);
  }

  AlarmsMsg* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<AlarmsMsg>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const AlarmsMsg& from);
  void MergeFrom(const AlarmsMsg& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(AlarmsMsg* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "AlarmsMsg";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_common_2eproto);
    return ::descriptor_table_common_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kAlarmsFieldNumber = 1,
  };
  // repeated .AlarmMsg alarms = 1;
  int alarms_size() const;
  void clear_alarms();
  ::AlarmMsg* mutable_alarms(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::AlarmMsg >*
      mutable_alarms();
  const ::AlarmMsg& alarms(int index) const;
  ::AlarmMsg* add_alarms();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::AlarmMsg >&
      alarms() const;

  // @@protoc_insertion_point(class_scope:AlarmsMsg)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::AlarmMsg > alarms_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_common_2eproto;
};
// -------------------------------------------------------------------

class TaskMsg :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:TaskMsg) */ {
 public:
  TaskMsg();
  virtual ~TaskMsg();

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

  inline TaskMsg& operator=(const TaskMsg& from) {
    CopyFrom(from);
    return *this;
  }
  inline TaskMsg& operator=(TaskMsg&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const TaskMsg& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TaskMsg* internal_default_instance() {
    return reinterpret_cast<const TaskMsg*>(
               &_TaskMsg_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    17;

  friend void swap(TaskMsg& a, TaskMsg& b) {
    a.Swap(&b);
  }
  inline void Swap(TaskMsg* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline TaskMsg* New() const final {
    return CreateMaybeMessage<TaskMsg>(nullptr);
  }

  TaskMsg* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<TaskMsg>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const TaskMsg& from);
  void MergeFrom(const TaskMsg& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TaskMsg* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "TaskMsg";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_common_2eproto);
    return ::descriptor_table_common_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kNameFieldNumber = 2,
    kBeginTimeFieldNumber = 3,
    kEndTimeFieldNumber = 4,
    kIdFieldNumber = 1,
    kDeoxygenMinuteFieldNumber = 5,
    kTotalUseTimeFieldNumber = 6,
    kLogMoldPositionFieldNumber = 7,
    kFinishLayerFieldNumber = 8,
    kIsFinishFieldNumber = 9,
    kIsContinuePrintFieldNumber = 10,
  };
  // string name = 2;
  void clear_name();
  const std::string& name() const;
  void set_name(const std::string& value);
  void set_name(std::string&& value);
  void set_name(const char* value);
  void set_name(const char* value, size_t size);
  std::string* mutable_name();
  std::string* release_name();
  void set_allocated_name(std::string* name);

  // string beginTime = 3;
  void clear_begintime();
  const std::string& begintime() const;
  void set_begintime(const std::string& value);
  void set_begintime(std::string&& value);
  void set_begintime(const char* value);
  void set_begintime(const char* value, size_t size);
  std::string* mutable_begintime();
  std::string* release_begintime();
  void set_allocated_begintime(std::string* begintime);

  // string endTime = 4;
  void clear_endtime();
  const std::string& endtime() const;
  void set_endtime(const std::string& value);
  void set_endtime(std::string&& value);
  void set_endtime(const char* value);
  void set_endtime(const char* value, size_t size);
  std::string* mutable_endtime();
  std::string* release_endtime();
  void set_allocated_endtime(std::string* endtime);

  // int64 id = 1;
  void clear_id();
  ::PROTOBUF_NAMESPACE_ID::int64 id() const;
  void set_id(::PROTOBUF_NAMESPACE_ID::int64 value);

  // int64 deoxygenMinute = 5;
  void clear_deoxygenminute();
  ::PROTOBUF_NAMESPACE_ID::int64 deoxygenminute() const;
  void set_deoxygenminute(::PROTOBUF_NAMESPACE_ID::int64 value);

  // int64 totalUseTime = 6;
  void clear_totalusetime();
  ::PROTOBUF_NAMESPACE_ID::int64 totalusetime() const;
  void set_totalusetime(::PROTOBUF_NAMESPACE_ID::int64 value);

  // float logMoldPosition = 7;
  void clear_logmoldposition();
  float logmoldposition() const;
  void set_logmoldposition(float value);

  // uint32 finishLayer = 8;
  void clear_finishlayer();
  ::PROTOBUF_NAMESPACE_ID::uint32 finishlayer() const;
  void set_finishlayer(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // bool isFinish = 9;
  void clear_isfinish();
  bool isfinish() const;
  void set_isfinish(bool value);

  // bool isContinuePrint = 10;
  void clear_iscontinueprint();
  bool iscontinueprint() const;
  void set_iscontinueprint(bool value);

  // @@protoc_insertion_point(class_scope:TaskMsg)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr begintime_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr endtime_;
  ::PROTOBUF_NAMESPACE_ID::int64 id_;
  ::PROTOBUF_NAMESPACE_ID::int64 deoxygenminute_;
  ::PROTOBUF_NAMESPACE_ID::int64 totalusetime_;
  float logmoldposition_;
  ::PROTOBUF_NAMESPACE_ID::uint32 finishlayer_;
  bool isfinish_;
  bool iscontinueprint_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_common_2eproto;
};
// -------------------------------------------------------------------

class TasksMsg :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:TasksMsg) */ {
 public:
  TasksMsg();
  virtual ~TasksMsg();

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

  inline TasksMsg& operator=(const TasksMsg& from) {
    CopyFrom(from);
    return *this;
  }
  inline TasksMsg& operator=(TasksMsg&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const TasksMsg& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TasksMsg* internal_default_instance() {
    return reinterpret_cast<const TasksMsg*>(
               &_TasksMsg_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    18;

  friend void swap(TasksMsg& a, TasksMsg& b) {
    a.Swap(&b);
  }
  inline void Swap(TasksMsg* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline TasksMsg* New() const final {
    return CreateMaybeMessage<TasksMsg>(nullptr);
  }

  TasksMsg* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<TasksMsg>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const TasksMsg& from);
  void MergeFrom(const TasksMsg& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TasksMsg* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "TasksMsg";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_common_2eproto);
    return ::descriptor_table_common_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kTasksFieldNumber = 1,
  };
  // repeated .TaskMsg tasks = 1;
  int tasks_size() const;
  void clear_tasks();
  ::TaskMsg* mutable_tasks(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::TaskMsg >*
      mutable_tasks();
  const ::TaskMsg& tasks(int index) const;
  ::TaskMsg* add_tasks();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::TaskMsg >&
      tasks() const;

  // @@protoc_insertion_point(class_scope:TasksMsg)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::TaskMsg > tasks_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_common_2eproto;
};
// -------------------------------------------------------------------

class LayerStateMsg :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:LayerStateMsg) */ {
 public:
  LayerStateMsg();
  virtual ~LayerStateMsg();

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

  inline LayerStateMsg& operator=(const LayerStateMsg& from) {
    CopyFrom(from);
    return *this;
  }
  inline LayerStateMsg& operator=(LayerStateMsg&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const LayerStateMsg& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const LayerStateMsg* internal_default_instance() {
    return reinterpret_cast<const LayerStateMsg*>(
               &_LayerStateMsg_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    19;

  friend void swap(LayerStateMsg& a, LayerStateMsg& b) {
    a.Swap(&b);
  }
  inline void Swap(LayerStateMsg* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline LayerStateMsg* New() const final {
    return CreateMaybeMessage<LayerStateMsg>(nullptr);
  }

  LayerStateMsg* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<LayerStateMsg>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const LayerStateMsg& from);
  void MergeFrom(const LayerStateMsg& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(LayerStateMsg* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "LayerStateMsg";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_common_2eproto);
    return ::descriptor_table_common_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kLayerDateTimeFieldNumber = 1,
    kLayerIndexFieldNumber = 2,
    kLogMoldPositionFieldNumber = 3,
    kLogOxygenFieldNumber = 4,
    kLogInnerTempFieldNumber = 5,
    kLogPlateTempFieldNumber = 6,
    kWindSpeedFieldNumber = 7,
    kInnerPressureFieldNumber = 8,
    kFanFreqFieldNumber = 9,
    kHumidityFieldNumber = 10,
    kWaterTempFieldNumber = 11,
  };
  // string layerDateTime = 1;
  void clear_layerdatetime();
  const std::string& layerdatetime() const;
  void set_layerdatetime(const std::string& value);
  void set_layerdatetime(std::string&& value);
  void set_layerdatetime(const char* value);
  void set_layerdatetime(const char* value, size_t size);
  std::string* mutable_layerdatetime();
  std::string* release_layerdatetime();
  void set_allocated_layerdatetime(std::string* layerdatetime);

  // uint32 layerIndex = 2;
  void clear_layerindex();
  ::PROTOBUF_NAMESPACE_ID::uint32 layerindex() const;
  void set_layerindex(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // float logMoldPosition = 3;
  void clear_logmoldposition();
  float logmoldposition() const;
  void set_logmoldposition(float value);

  // float logOxygen = 4;
  void clear_logoxygen();
  float logoxygen() const;
  void set_logoxygen(float value);

  // float logInnerTemp = 5;
  void clear_loginnertemp();
  float loginnertemp() const;
  void set_loginnertemp(float value);

  // float logPlateTemp = 6;
  void clear_logplatetemp();
  float logplatetemp() const;
  void set_logplatetemp(float value);

  // float windSpeed = 7;
  void clear_windspeed();
  float windspeed() const;
  void set_windspeed(float value);

  // float innerPressure = 8;
  void clear_innerpressure();
  float innerpressure() const;
  void set_innerpressure(float value);

  // float fanFreq = 9;
  void clear_fanfreq();
  float fanfreq() const;
  void set_fanfreq(float value);

  // float humidity = 10;
  void clear_humidity();
  float humidity() const;
  void set_humidity(float value);

  // float waterTemp = 11;
  void clear_watertemp();
  float watertemp() const;
  void set_watertemp(float value);

  // @@protoc_insertion_point(class_scope:LayerStateMsg)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr layerdatetime_;
  ::PROTOBUF_NAMESPACE_ID::uint32 layerindex_;
  float logmoldposition_;
  float logoxygen_;
  float loginnertemp_;
  float logplatetemp_;
  float windspeed_;
  float innerpressure_;
  float fanfreq_;
  float humidity_;
  float watertemp_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_common_2eproto;
};
// -------------------------------------------------------------------

class LayerStatesMsg :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:LayerStatesMsg) */ {
 public:
  LayerStatesMsg();
  virtual ~LayerStatesMsg();

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

  inline LayerStatesMsg& operator=(const LayerStatesMsg& from) {
    CopyFrom(from);
    return *this;
  }
  inline LayerStatesMsg& operator=(LayerStatesMsg&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const LayerStatesMsg& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const LayerStatesMsg* internal_default_instance() {
    return reinterpret_cast<const LayerStatesMsg*>(
               &_LayerStatesMsg_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    20;

  friend void swap(LayerStatesMsg& a, LayerStatesMsg& b) {
    a.Swap(&b);
  }
  inline void Swap(LayerStatesMsg* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline LayerStatesMsg* New() const final {
    return CreateMaybeMessage<LayerStatesMsg>(nullptr);
  }

  LayerStatesMsg* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<LayerStatesMsg>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const LayerStatesMsg& from);
  void MergeFrom(const LayerStatesMsg& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(LayerStatesMsg* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "LayerStatesMsg";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_common_2eproto);
    return ::descriptor_table_common_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kLayerStatesFieldNumber = 1,
  };
  // repeated .LayerStateMsg layerStates = 1;
  int layerstates_size() const;
  void clear_layerstates();
  ::LayerStateMsg* mutable_layerstates(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::LayerStateMsg >*
      mutable_layerstates();
  const ::LayerStateMsg& layerstates(int index) const;
  ::LayerStateMsg* add_layerstates();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::LayerStateMsg >&
      layerstates() const;

  // @@protoc_insertion_point(class_scope:LayerStatesMsg)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::LayerStateMsg > layerstates_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_common_2eproto;
};
// -------------------------------------------------------------------

class LayerImageMsg :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:LayerImageMsg) */ {
 public:
  LayerImageMsg();
  virtual ~LayerImageMsg();

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

  inline LayerImageMsg& operator=(const LayerImageMsg& from) {
    CopyFrom(from);
    return *this;
  }
  inline LayerImageMsg& operator=(LayerImageMsg&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const LayerImageMsg& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const LayerImageMsg* internal_default_instance() {
    return reinterpret_cast<const LayerImageMsg*>(
               &_LayerImageMsg_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    21;

  friend void swap(LayerImageMsg& a, LayerImageMsg& b) {
    a.Swap(&b);
  }
  inline void Swap(LayerImageMsg* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline LayerImageMsg* New() const final {
    return CreateMaybeMessage<LayerImageMsg>(nullptr);
  }

  LayerImageMsg* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<LayerImageMsg>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const LayerImageMsg& from);
  void MergeFrom(const LayerImageMsg& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(LayerImageMsg* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "LayerImageMsg";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_common_2eproto);
    return ::descriptor_table_common_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kTypeFieldNumber = 3,
    kIdFieldNumber = 1,
    kLayerFieldNumber = 2,
  };
  // string type = 3;
  void clear_type();
  const std::string& type() const;
  void set_type(const std::string& value);
  void set_type(std::string&& value);
  void set_type(const char* value);
  void set_type(const char* value, size_t size);
  std::string* mutable_type();
  std::string* release_type();
  void set_allocated_type(std::string* type);

  // int64 id = 1;
  void clear_id();
  ::PROTOBUF_NAMESPACE_ID::int64 id() const;
  void set_id(::PROTOBUF_NAMESPACE_ID::int64 value);

  // uint32 layer = 2;
  void clear_layer();
  ::PROTOBUF_NAMESPACE_ID::uint32 layer() const;
  void set_layer(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // @@protoc_insertion_point(class_scope:LayerImageMsg)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr type_;
  ::PROTOBUF_NAMESPACE_ID::int64 id_;
  ::PROTOBUF_NAMESPACE_ID::uint32 layer_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_common_2eproto;
};
// -------------------------------------------------------------------

class LayerImagesMsg :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:LayerImagesMsg) */ {
 public:
  LayerImagesMsg();
  virtual ~LayerImagesMsg();

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

  inline LayerImagesMsg& operator=(const LayerImagesMsg& from) {
    CopyFrom(from);
    return *this;
  }
  inline LayerImagesMsg& operator=(LayerImagesMsg&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const LayerImagesMsg& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const LayerImagesMsg* internal_default_instance() {
    return reinterpret_cast<const LayerImagesMsg*>(
               &_LayerImagesMsg_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    22;

  friend void swap(LayerImagesMsg& a, LayerImagesMsg& b) {
    a.Swap(&b);
  }
  inline void Swap(LayerImagesMsg* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline LayerImagesMsg* New() const final {
    return CreateMaybeMessage<LayerImagesMsg>(nullptr);
  }

  LayerImagesMsg* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<LayerImagesMsg>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const LayerImagesMsg& from);
  void MergeFrom(const LayerImagesMsg& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(LayerImagesMsg* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "LayerImagesMsg";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_common_2eproto);
    return ::descriptor_table_common_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kImagesFieldNumber = 1,
  };
  // repeated .LayerImageMsg images = 1;
  int images_size() const;
  void clear_images();
  ::LayerImageMsg* mutable_images(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::LayerImageMsg >*
      mutable_images();
  const ::LayerImageMsg& images(int index) const;
  ::LayerImageMsg* add_images();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::LayerImageMsg >&
      images() const;

  // @@protoc_insertion_point(class_scope:LayerImagesMsg)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::LayerImageMsg > images_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_common_2eproto;
};
// -------------------------------------------------------------------

class LayerImageDataMsg :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:LayerImageDataMsg) */ {
 public:
  LayerImageDataMsg();
  virtual ~LayerImageDataMsg();

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

  inline LayerImageDataMsg& operator=(const LayerImageDataMsg& from) {
    CopyFrom(from);
    return *this;
  }
  inline LayerImageDataMsg& operator=(LayerImageDataMsg&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const LayerImageDataMsg& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const LayerImageDataMsg* internal_default_instance() {
    return reinterpret_cast<const LayerImageDataMsg*>(
               &_LayerImageDataMsg_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    23;

  friend void swap(LayerImageDataMsg& a, LayerImageDataMsg& b) {
    a.Swap(&b);
  }
  inline void Swap(LayerImageDataMsg* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline LayerImageDataMsg* New() const final {
    return CreateMaybeMessage<LayerImageDataMsg>(nullptr);
  }

  LayerImageDataMsg* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<LayerImageDataMsg>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const LayerImageDataMsg& from);
  void MergeFrom(const LayerImageDataMsg& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(LayerImageDataMsg* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "LayerImageDataMsg";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_common_2eproto);
    return ::descriptor_table_common_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kImageDataFieldNumber = 2,
    kImageSizeFieldNumber = 1,
  };
  // bytes imageData = 2;
  void clear_imagedata();
  const std::string& imagedata() const;
  void set_imagedata(const std::string& value);
  void set_imagedata(std::string&& value);
  void set_imagedata(const char* value);
  void set_imagedata(const void* value, size_t size);
  std::string* mutable_imagedata();
  std::string* release_imagedata();
  void set_allocated_imagedata(std::string* imagedata);

  // uint64 imageSize = 1;
  void clear_imagesize();
  ::PROTOBUF_NAMESPACE_ID::uint64 imagesize() const;
  void set_imagesize(::PROTOBUF_NAMESPACE_ID::uint64 value);

  // @@protoc_insertion_point(class_scope:LayerImageDataMsg)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr imagedata_;
  ::PROTOBUF_NAMESPACE_ID::uint64 imagesize_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_common_2eproto;
};
// -------------------------------------------------------------------

class LayerLoadCurveMsg :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:LayerLoadCurveMsg) */ {
 public:
  LayerLoadCurveMsg();
  virtual ~LayerLoadCurveMsg();

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

  inline LayerLoadCurveMsg& operator=(const LayerLoadCurveMsg& from) {
    CopyFrom(from);
    return *this;
  }
  inline LayerLoadCurveMsg& operator=(LayerLoadCurveMsg&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const LayerLoadCurveMsg& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const LayerLoadCurveMsg* internal_default_instance() {
    return reinterpret_cast<const LayerLoadCurveMsg*>(
               &_LayerLoadCurveMsg_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    24;

  friend void swap(LayerLoadCurveMsg& a, LayerLoadCurveMsg& b) {
    a.Swap(&b);
  }
  inline void Swap(LayerLoadCurveMsg* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline LayerLoadCurveMsg* New() const final {
    return CreateMaybeMessage<LayerLoadCurveMsg>(nullptr);
  }

  LayerLoadCurveMsg* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<LayerLoadCurveMsg>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const LayerLoadCurveMsg& from);
  void MergeFrom(const LayerLoadCurveMsg& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(LayerLoadCurveMsg* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "LayerLoadCurveMsg";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_common_2eproto);
    return ::descriptor_table_common_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kCoverTypeFieldNumber = 3,
    kIdFieldNumber = 1,
    kLayerFieldNumber = 2,
  };
  // string coverType = 3;
  void clear_covertype();
  const std::string& covertype() const;
  void set_covertype(const std::string& value);
  void set_covertype(std::string&& value);
  void set_covertype(const char* value);
  void set_covertype(const char* value, size_t size);
  std::string* mutable_covertype();
  std::string* release_covertype();
  void set_allocated_covertype(std::string* covertype);

  // int64 id = 1;
  void clear_id();
  ::PROTOBUF_NAMESPACE_ID::int64 id() const;
  void set_id(::PROTOBUF_NAMESPACE_ID::int64 value);

  // uint32 layer = 2;
  void clear_layer();
  ::PROTOBUF_NAMESPACE_ID::uint32 layer() const;
  void set_layer(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // @@protoc_insertion_point(class_scope:LayerLoadCurveMsg)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr covertype_;
  ::PROTOBUF_NAMESPACE_ID::int64 id_;
  ::PROTOBUF_NAMESPACE_ID::uint32 layer_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_common_2eproto;
};
// -------------------------------------------------------------------

class LayerLoadCurvesMsg :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:LayerLoadCurvesMsg) */ {
 public:
  LayerLoadCurvesMsg();
  virtual ~LayerLoadCurvesMsg();

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

  inline LayerLoadCurvesMsg& operator=(const LayerLoadCurvesMsg& from) {
    CopyFrom(from);
    return *this;
  }
  inline LayerLoadCurvesMsg& operator=(LayerLoadCurvesMsg&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const LayerLoadCurvesMsg& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const LayerLoadCurvesMsg* internal_default_instance() {
    return reinterpret_cast<const LayerLoadCurvesMsg*>(
               &_LayerLoadCurvesMsg_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    25;

  friend void swap(LayerLoadCurvesMsg& a, LayerLoadCurvesMsg& b) {
    a.Swap(&b);
  }
  inline void Swap(LayerLoadCurvesMsg* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline LayerLoadCurvesMsg* New() const final {
    return CreateMaybeMessage<LayerLoadCurvesMsg>(nullptr);
  }

  LayerLoadCurvesMsg* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<LayerLoadCurvesMsg>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const LayerLoadCurvesMsg& from);
  void MergeFrom(const LayerLoadCurvesMsg& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(LayerLoadCurvesMsg* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "LayerLoadCurvesMsg";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_common_2eproto);
    return ::descriptor_table_common_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kLoadCurvesFieldNumber = 1,
  };
  // repeated .LayerLoadCurveMsg loadCurves = 1;
  int loadcurves_size() const;
  void clear_loadcurves();
  ::LayerLoadCurveMsg* mutable_loadcurves(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::LayerLoadCurveMsg >*
      mutable_loadcurves();
  const ::LayerLoadCurveMsg& loadcurves(int index) const;
  ::LayerLoadCurveMsg* add_loadcurves();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::LayerLoadCurveMsg >&
      loadcurves() const;

  // @@protoc_insertion_point(class_scope:LayerLoadCurvesMsg)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::LayerLoadCurveMsg > loadcurves_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_common_2eproto;
};
// -------------------------------------------------------------------

class LayerLoadCurveDataMsg :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:LayerLoadCurveDataMsg) */ {
 public:
  LayerLoadCurveDataMsg();
  virtual ~LayerLoadCurveDataMsg();

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

  inline LayerLoadCurveDataMsg& operator=(const LayerLoadCurveDataMsg& from) {
    CopyFrom(from);
    return *this;
  }
  inline LayerLoadCurveDataMsg& operator=(LayerLoadCurveDataMsg&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const LayerLoadCurveDataMsg& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const LayerLoadCurveDataMsg* internal_default_instance() {
    return reinterpret_cast<const LayerLoadCurveDataMsg*>(
               &_LayerLoadCurveDataMsg_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    26;

  friend void swap(LayerLoadCurveDataMsg& a, LayerLoadCurveDataMsg& b) {
    a.Swap(&b);
  }
  inline void Swap(LayerLoadCurveDataMsg* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline LayerLoadCurveDataMsg* New() const final {
    return CreateMaybeMessage<LayerLoadCurveDataMsg>(nullptr);
  }

  LayerLoadCurveDataMsg* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<LayerLoadCurveDataMsg>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const LayerLoadCurveDataMsg& from);
  void MergeFrom(const LayerLoadCurveDataMsg& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(LayerLoadCurveDataMsg* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "LayerLoadCurveDataMsg";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_common_2eproto);
    return ::descriptor_table_common_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kMoldFieldNumber = 1,
    kPowderFieldNumber = 2,
    kArmFieldNumber = 3,
  };
  // repeated float mold = 1;
  int mold_size() const;
  void clear_mold();
  float mold(int index) const;
  void set_mold(int index, float value);
  void add_mold(float value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      mold() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      mutable_mold();

  // repeated float powder = 2;
  int powder_size() const;
  void clear_powder();
  float powder(int index) const;
  void set_powder(int index, float value);
  void add_powder(float value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      powder() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      mutable_powder();

  // repeated float arm = 3;
  int arm_size() const;
  void clear_arm();
  float arm(int index) const;
  void set_arm(int index, float value);
  void add_arm(float value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      arm() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      mutable_arm();

  // @@protoc_insertion_point(class_scope:LayerLoadCurveDataMsg)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > mold_;
  mutable std::atomic<int> _mold_cached_byte_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > powder_;
  mutable std::atomic<int> _powder_cached_byte_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > arm_;
  mutable std::atomic<int> _arm_cached_byte_size_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_common_2eproto;
};
// -------------------------------------------------------------------

class LogReqMsg :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:LogReqMsg) */ {
 public:
  LogReqMsg();
  virtual ~LogReqMsg();

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

  inline LogReqMsg& operator=(const LogReqMsg& from) {
    CopyFrom(from);
    return *this;
  }
  inline LogReqMsg& operator=(LogReqMsg&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const LogReqMsg& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const LogReqMsg* internal_default_instance() {
    return reinterpret_cast<const LogReqMsg*>(
               &_LogReqMsg_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    27;

  friend void swap(LogReqMsg& a, LogReqMsg& b) {
    a.Swap(&b);
  }
  inline void Swap(LogReqMsg* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline LogReqMsg* New() const final {
    return CreateMaybeMessage<LogReqMsg>(nullptr);
  }

  LogReqMsg* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<LogReqMsg>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const LogReqMsg& from);
  void MergeFrom(const LogReqMsg& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(LogReqMsg* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "LogReqMsg";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_common_2eproto);
    return ::descriptor_table_common_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

  typedef LogReqMsg_LogType LogType;
  static constexpr LogType ALARM =
    LogReqMsg_LogType_ALARM;
  static constexpr LogType TASK =
    LogReqMsg_LogType_TASK;
  static constexpr LogType LAYERSTATE =
    LogReqMsg_LogType_LAYERSTATE;
  static constexpr LogType LAYERIMAGE =
    LogReqMsg_LogType_LAYERIMAGE;
  static constexpr LogType IMAGE =
    LogReqMsg_LogType_IMAGE;
  static constexpr LogType LAYERLOADCURVE =
    LogReqMsg_LogType_LAYERLOADCURVE;
  static constexpr LogType LOADCURVE =
    LogReqMsg_LogType_LOADCURVE;
  static inline bool LogType_IsValid(int value) {
    return LogReqMsg_LogType_IsValid(value);
  }
  static constexpr LogType LogType_MIN =
    LogReqMsg_LogType_LogType_MIN;
  static constexpr LogType LogType_MAX =
    LogReqMsg_LogType_LogType_MAX;
  static constexpr int LogType_ARRAYSIZE =
    LogReqMsg_LogType_LogType_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  LogType_descriptor() {
    return LogReqMsg_LogType_descriptor();
  }
  template<typename T>
  static inline const std::string& LogType_Name(T enum_t_value) {
    static_assert(::std::is_same<T, LogType>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function LogType_Name.");
    return LogReqMsg_LogType_Name(enum_t_value);
  }
  static inline bool LogType_Parse(const std::string& name,
      LogType* value) {
    return LogReqMsg_LogType_Parse(name, value);
  }

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

  enum : int {
    kTypeFieldNumber = 1,
    kIndexFieldNumber = 2,
    kPageSizeFieldNumber = 3,
  };
  // .LogReqMsg.LogType type = 1;
  void clear_type();
  ::LogReqMsg_LogType type() const;
  void set_type(::LogReqMsg_LogType value);

  // uint32 index = 2;
  void clear_index();
  ::PROTOBUF_NAMESPACE_ID::uint32 index() const;
  void set_index(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // uint32 pageSize = 3;
  void clear_pagesize();
  ::PROTOBUF_NAMESPACE_ID::uint32 pagesize() const;
  void set_pagesize(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // @@protoc_insertion_point(class_scope:LogReqMsg)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  int type_;
  ::PROTOBUF_NAMESPACE_ID::uint32 index_;
  ::PROTOBUF_NAMESPACE_ID::uint32 pagesize_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_common_2eproto;
};
// -------------------------------------------------------------------

class LogRespMsg :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:LogRespMsg) */ {
 public:
  LogRespMsg();
  virtual ~LogRespMsg();

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

  inline LogRespMsg& operator=(const LogRespMsg& from) {
    CopyFrom(from);
    return *this;
  }
  inline LogRespMsg& operator=(LogRespMsg&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const LogRespMsg& default_instance();

  enum LogrespCase {
    kAlarms = 4,
    kTasks = 5,
    kStates = 6,
    kImages = 7,
    kImageData = 8,
    kLoadCurves = 9,
    kLoadCurveData = 10,
    LOGRESP_NOT_SET = 0,
  };

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const LogRespMsg* internal_default_instance() {
    return reinterpret_cast<const LogRespMsg*>(
               &_LogRespMsg_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    28;

  friend void swap(LogRespMsg& a, LogRespMsg& b) {
    a.Swap(&b);
  }
  inline void Swap(LogRespMsg* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline LogRespMsg* New() const final {
    return CreateMaybeMessage<LogRespMsg>(nullptr);
  }

  LogRespMsg* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<LogRespMsg>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const LogRespMsg& from);
  void MergeFrom(const LogRespMsg& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(LogRespMsg* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "LogRespMsg";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_common_2eproto);
    return ::descriptor_table_common_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kIndexFieldNumber = 1,
    kPageSizeFieldNumber = 2,
    kTotalFieldNumber = 3,
    kAlarmsFieldNumber = 4,
    kTasksFieldNumber = 5,
    kStatesFieldNumber = 6,
    kImagesFieldNumber = 7,
    kImageDataFieldNumber = 8,
    kLoadCurvesFieldNumber = 9,
    kLoadCurveDataFieldNumber = 10,
  };
  // uint32 index = 1;
  void clear_index();
  ::PROTOBUF_NAMESPACE_ID::uint32 index() const;
  void set_index(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // uint32 pageSize = 2;
  void clear_pagesize();
  ::PROTOBUF_NAMESPACE_ID::uint32 pagesize() const;
  void set_pagesize(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // uint32 total = 3;
  void clear_total();
  ::PROTOBUF_NAMESPACE_ID::uint32 total() const;
  void set_total(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // .AlarmsMsg alarms = 4;
  bool has_alarms() const;
  void clear_alarms();
  const ::AlarmsMsg& alarms() const;
  ::AlarmsMsg* release_alarms();
  ::AlarmsMsg* mutable_alarms();
  void set_allocated_alarms(::AlarmsMsg* alarms);

  // .TasksMsg tasks = 5;
  bool has_tasks() const;
  void clear_tasks();
  const ::TasksMsg& tasks() const;
  ::TasksMsg* release_tasks();
  ::TasksMsg* mutable_tasks();
  void set_allocated_tasks(::TasksMsg* tasks);

  // .LayerStatesMsg states = 6;
  bool has_states() const;
  void clear_states();
  const ::LayerStatesMsg& states() const;
  ::LayerStatesMsg* release_states();
  ::LayerStatesMsg* mutable_states();
  void set_allocated_states(::LayerStatesMsg* states);

  // .LayerImagesMsg images = 7;
  bool has_images() const;
  void clear_images();
  const ::LayerImagesMsg& images() const;
  ::LayerImagesMsg* release_images();
  ::LayerImagesMsg* mutable_images();
  void set_allocated_images(::LayerImagesMsg* images);

  // .LayerImageDataMsg imageData = 8;
  bool has_imagedata() const;
  void clear_imagedata();
  const ::LayerImageDataMsg& imagedata() const;
  ::LayerImageDataMsg* release_imagedata();
  ::LayerImageDataMsg* mutable_imagedata();
  void set_allocated_imagedata(::LayerImageDataMsg* imagedata);

  // .LayerLoadCurvesMsg loadCurves = 9;
  bool has_loadcurves() const;
  void clear_loadcurves();
  const ::LayerLoadCurvesMsg& loadcurves() const;
  ::LayerLoadCurvesMsg* release_loadcurves();
  ::LayerLoadCurvesMsg* mutable_loadcurves();
  void set_allocated_loadcurves(::LayerLoadCurvesMsg* loadcurves);

  // .LayerLoadCurveDataMsg loadCurveData = 10;
  bool has_loadcurvedata() const;
  void clear_loadcurvedata();
  const ::LayerLoadCurveDataMsg& loadcurvedata() const;
  ::LayerLoadCurveDataMsg* release_loadcurvedata();
  ::LayerLoadCurveDataMsg* mutable_loadcurvedata();
  void set_allocated_loadcurvedata(::LayerLoadCurveDataMsg* loadcurvedata);

  void clear_logresp();
  LogrespCase logresp_case() const;
  // @@protoc_insertion_point(class_scope:LogRespMsg)
 private:
  class _Internal;
  void set_has_alarms();
  void set_has_tasks();
  void set_has_states();
  void set_has_images();
  void set_has_imagedata();
  void set_has_loadcurves();
  void set_has_loadcurvedata();

  inline bool has_logresp() const;
  inline void clear_has_logresp();

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::uint32 index_;
  ::PROTOBUF_NAMESPACE_ID::uint32 pagesize_;
  ::PROTOBUF_NAMESPACE_ID::uint32 total_;
  union LogrespUnion {
    LogrespUnion() {}
    ::AlarmsMsg* alarms_;
    ::TasksMsg* tasks_;
    ::LayerStatesMsg* states_;
    ::LayerImagesMsg* images_;
    ::LayerImageDataMsg* imagedata_;
    ::LayerLoadCurvesMsg* loadcurves_;
    ::LayerLoadCurveDataMsg* loadcurvedata_;
  } logresp_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];

  friend struct ::TableStruct_common_2eproto;
};
// -------------------------------------------------------------------

class LogFetchReqMsg :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:LogFetchReqMsg) */ {
 public:
  LogFetchReqMsg();
  virtual ~LogFetchReqMsg();

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

  inline LogFetchReqMsg& operator=(const LogFetchReqMsg& from) {
    CopyFrom(from);
    return *this;
  }
  inline LogFetchReqMsg& operator=(LogFetchReqMsg&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const LogFetchReqMsg& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const LogFetchReqMsg* internal_default_instance() {
    return reinterpret_cast<const LogFetchReqMsg*>(
               &_LogFetchReqMsg_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    29;

  friend void swap(LogFetchReqMsg& a, LogFetchReqMsg& b) {
    a.Swap(&b);
  }
  inline void Swap(LogFetchReqMsg* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline LogFetchReqMsg* New() const final {
    return CreateMaybeMessage<LogFetchReqMsg>(nullptr);
  }

  LogFetchReqMsg* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<LogFetchReqMsg>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const LogFetchReqMsg& from);
  void MergeFrom(const LogFetchReqMsg& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(LogFetchReqMsg* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "LogFetchReqMsg";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_common_2eproto);
    return ::descriptor_table_common_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

  typedef LogFetchReqMsg_LogType LogType;
  static constexpr LogType ALARM =
    LogFetchReqMsg_LogType_ALARM;
  static constexpr LogType TASKLIST =
    LogFetchReqMsg_LogType_TASKLIST;
  static constexpr LogType TASK =
    LogFetchReqMsg_LogType_TASK;
  static inline bool LogType_IsValid(int value) {
    return LogFetchReqMsg_LogType_IsValid(value);
  }
  static constexpr LogType LogType_MIN =
    LogFetchReqMsg_LogType_LogType_MIN;
  static constexpr LogType LogType_MAX =
    LogFetchReqMsg_LogType_LogType_MAX;
  static constexpr int LogType_ARRAYSIZE =
    LogFetchReqMsg_LogType_LogType_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  LogType_descriptor() {
    return LogFetchReqMsg_LogType_descriptor();
  }
  template<typename T>
  static inline const std::string& LogType_Name(T enum_t_value) {
    static_assert(::std::is_same<T, LogType>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function LogType_Name.");
    return LogFetchReqMsg_LogType_Name(enum_t_value);
  }
  static inline bool LogType_Parse(const std::string& name,
      LogType* value) {
    return LogFetchReqMsg_LogType_Parse(name, value);
  }

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

  enum : int {
    kBeginFieldNumber = 2,
    kEndFieldNumber = 3,
    kTypeFieldNumber = 1,
  };
  // int64 begin = 2;
  void clear_begin();
  ::PROTOBUF_NAMESPACE_ID::int64 begin() const;
  void set_begin(::PROTOBUF_NAMESPACE_ID::int64 value);

  // int64 end = 3;
  void clear_end();
  ::PROTOBUF_NAMESPACE_ID::int64 end() const;
  void set_end(::PROTOBUF_NAMESPACE_ID::int64 value);

  // .LogFetchReqMsg.LogType type = 1;
  void clear_type();
  ::LogFetchReqMsg_LogType type() const;
  void set_type(::LogFetchReqMsg_LogType value);

  // @@protoc_insertion_point(class_scope:LogFetchReqMsg)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::int64 begin_;
  ::PROTOBUF_NAMESPACE_ID::int64 end_;
  int type_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_common_2eproto;
};
// ===================================================================


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

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

// float oxygenValue = 1;
inline void StateMsg::clear_oxygenvalue() {
  oxygenvalue_ = 0;
}
inline float StateMsg::oxygenvalue() const {
  // @@protoc_insertion_point(field_get:StateMsg.oxygenValue)
  return oxygenvalue_;
}
inline void StateMsg::set_oxygenvalue(float value) {
  
  oxygenvalue_ = value;
  // @@protoc_insertion_point(field_set:StateMsg.oxygenValue)
}

// float ambientTemp = 2;
inline void StateMsg::clear_ambienttemp() {
  ambienttemp_ = 0;
}
inline float StateMsg::ambienttemp() const {
  // @@protoc_insertion_point(field_get:StateMsg.ambientTemp)
  return ambienttemp_;
}
inline void StateMsg::set_ambienttemp(float value) {
  
  ambienttemp_ = value;
  // @@protoc_insertion_point(field_set:StateMsg.ambientTemp)
}

// float innerTemp = 3;
inline void StateMsg::clear_innertemp() {
  innertemp_ = 0;
}
inline float StateMsg::innertemp() const {
  // @@protoc_insertion_point(field_get:StateMsg.innerTemp)
  return innertemp_;
}
inline void StateMsg::set_innertemp(float value) {
  
  innertemp_ = value;
  // @@protoc_insertion_point(field_set:StateMsg.innerTemp)
}

// float windValue = 4;
inline void StateMsg::clear_windvalue() {
  windvalue_ = 0;
}
inline float StateMsg::windvalue() const {
  // @@protoc_insertion_point(field_get:StateMsg.windValue)
  return windvalue_;
}
inline void StateMsg::set_windvalue(float value) {
  
  windvalue_ = value;
  // @@protoc_insertion_point(field_set:StateMsg.windValue)
}

// float platformTempValue = 5;
inline void StateMsg::clear_platformtempvalue() {
  platformtempvalue_ = 0;
}
inline float StateMsg::platformtempvalue() const {
  // @@protoc_insertion_point(field_get:StateMsg.platformTempValue)
  return platformtempvalue_;
}
inline void StateMsg::set_platformtempvalue(float value) {
  
  platformtempvalue_ = value;
  // @@protoc_insertion_point(field_set:StateMsg.platformTempValue)
}

// float platformTempSettingValue = 6;
inline void StateMsg::clear_platformtempsettingvalue() {
  platformtempsettingvalue_ = 0;
}
inline float StateMsg::platformtempsettingvalue() const {
  // @@protoc_insertion_point(field_get:StateMsg.platformTempSettingValue)
  return platformtempsettingvalue_;
}
inline void StateMsg::set_platformtempsettingvalue(float value) {
  
  platformtempsettingvalue_ = value;
  // @@protoc_insertion_point(field_set:StateMsg.platformTempSettingValue)
}

// float moldPos = 7;
inline void StateMsg::clear_moldpos() {
  moldpos_ = 0;
}
inline float StateMsg::moldpos() const {
  // @@protoc_insertion_point(field_get:StateMsg.moldPos)
  return moldpos_;
}
inline void StateMsg::set_moldpos(float value) {
  
  moldpos_ = value;
  // @@protoc_insertion_point(field_set:StateMsg.moldPos)
}

// float powderPos = 8;
inline void StateMsg::clear_powderpos() {
  powderpos_ = 0;
}
inline float StateMsg::powderpos() const {
  // @@protoc_insertion_point(field_get:StateMsg.powderPos)
  return powderpos_;
}
inline void StateMsg::set_powderpos(float value) {
  
  powderpos_ = value;
  // @@protoc_insertion_point(field_set:StateMsg.powderPos)
}

// float armPos = 9;
inline void StateMsg::clear_armpos() {
  armpos_ = 0;
}
inline float StateMsg::armpos() const {
  // @@protoc_insertion_point(field_get:StateMsg.armPos)
  return armpos_;
}
inline void StateMsg::set_armpos(float value) {
  
  armpos_ = value;
  // @@protoc_insertion_point(field_set:StateMsg.armPos)
}

// .StateMsg.PrintState printState = 10;
inline void StateMsg::clear_printstate() {
  printstate_ = 0;
}
inline ::StateMsg_PrintState StateMsg::printstate() const {
  // @@protoc_insertion_point(field_get:StateMsg.printState)
  return static_cast< ::StateMsg_PrintState >(printstate_);
}
inline void StateMsg::set_printstate(::StateMsg_PrintState value) {
  
  printstate_ = value;
  // @@protoc_insertion_point(field_set:StateMsg.printState)
}

// int32 layerIndex = 11;
inline void StateMsg::clear_layerindex() {
  layerindex_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 StateMsg::layerindex() const {
  // @@protoc_insertion_point(field_get:StateMsg.layerIndex)
  return layerindex_;
}
inline void StateMsg::set_layerindex(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  layerindex_ = value;
  // @@protoc_insertion_point(field_set:StateMsg.layerIndex)
}

// int32 limitFlag = 12;
inline void StateMsg::clear_limitflag() {
  limitflag_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 StateMsg::limitflag() const {
  // @@protoc_insertion_point(field_get:StateMsg.limitFlag)
  return limitflag_;
}
inline void StateMsg::set_limitflag(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  limitflag_ = value;
  // @@protoc_insertion_point(field_set:StateMsg.limitFlag)
}

// string machineId = 13;
inline void StateMsg::clear_machineid() {
  machineid_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& StateMsg::machineid() const {
  // @@protoc_insertion_point(field_get:StateMsg.machineId)
  return machineid_.GetNoArena();
}
inline void StateMsg::set_machineid(const std::string& value) {
  
  machineid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:StateMsg.machineId)
}
inline void StateMsg::set_machineid(std::string&& value) {
  
  machineid_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:StateMsg.machineId)
}
inline void StateMsg::set_machineid(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  machineid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:StateMsg.machineId)
}
inline void StateMsg::set_machineid(const char* value, size_t size) {
  
  machineid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:StateMsg.machineId)
}
inline std::string* StateMsg::mutable_machineid() {
  
  // @@protoc_insertion_point(field_mutable:StateMsg.machineId)
  return machineid_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* StateMsg::release_machineid() {
  // @@protoc_insertion_point(field_release:StateMsg.machineId)
  
  return machineid_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void StateMsg::set_allocated_machineid(std::string* machineid) {
  if (machineid != nullptr) {
    
  } else {
    
  }
  machineid_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), machineid);
  // @@protoc_insertion_point(field_set_allocated:StateMsg.machineId)
}

// bool isDoorClose = 14;
inline void StateMsg::clear_isdoorclose() {
  isdoorclose_ = false;
}
inline bool StateMsg::isdoorclose() const {
  // @@protoc_insertion_point(field_get:StateMsg.isDoorClose)
  return isdoorclose_;
}
inline void StateMsg::set_isdoorclose(bool value) {
  
  isdoorclose_ = value;
  // @@protoc_insertion_point(field_set:StateMsg.isDoorClose)
}

// uint32 accTime = 15;
inline void StateMsg::clear_acctime() {
  acctime_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 StateMsg::acctime() const {
  // @@protoc_insertion_point(field_get:StateMsg.accTime)
  return acctime_;
}
inline void StateMsg::set_acctime(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  acctime_ = value;
  // @@protoc_insertion_point(field_set:StateMsg.accTime)
}

// uint32 remainTime = 16;
inline void StateMsg::clear_remaintime() {
  remaintime_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 StateMsg::remaintime() const {
  // @@protoc_insertion_point(field_get:StateMsg.remainTime)
  return remaintime_;
}
inline void StateMsg::set_remaintime(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  remaintime_ = value;
  // @@protoc_insertion_point(field_set:StateMsg.remainTime)
}

// uint32 totalTime = 17;
inline void StateMsg::clear_totaltime() {
  totaltime_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 StateMsg::totaltime() const {
  // @@protoc_insertion_point(field_get:StateMsg.totalTime)
  return totaltime_;
}
inline void StateMsg::set_totaltime(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  totaltime_ = value;
  // @@protoc_insertion_point(field_set:StateMsg.totalTime)
}

// int32 layerCount = 18;
inline void StateMsg::clear_layercount() {
  layercount_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 StateMsg::layercount() const {
  // @@protoc_insertion_point(field_get:StateMsg.layerCount)
  return layercount_;
}
inline void StateMsg::set_layercount(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  layercount_ = value;
  // @@protoc_insertion_point(field_set:StateMsg.layerCount)
}

// int64 printTime = 19;
inline void StateMsg::clear_printtime() {
  printtime_ = PROTOBUF_LONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::int64 StateMsg::printtime() const {
  // @@protoc_insertion_point(field_get:StateMsg.printTime)
  return printtime_;
}
inline void StateMsg::set_printtime(::PROTOBUF_NAMESPACE_ID::int64 value) {
  
  printtime_ = value;
  // @@protoc_insertion_point(field_set:StateMsg.printTime)
}

// string material = 20;
inline void StateMsg::clear_material() {
  material_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& StateMsg::material() const {
  // @@protoc_insertion_point(field_get:StateMsg.material)
  return material_.GetNoArena();
}
inline void StateMsg::set_material(const std::string& value) {
  
  material_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:StateMsg.material)
}
inline void StateMsg::set_material(std::string&& value) {
  
  material_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:StateMsg.material)
}
inline void StateMsg::set_material(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  material_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:StateMsg.material)
}
inline void StateMsg::set_material(const char* value, size_t size) {
  
  material_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:StateMsg.material)
}
inline std::string* StateMsg::mutable_material() {
  
  // @@protoc_insertion_point(field_mutable:StateMsg.material)
  return material_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* StateMsg::release_material() {
  // @@protoc_insertion_point(field_release:StateMsg.material)
  
  return material_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void StateMsg::set_allocated_material(std::string* material) {
  if (material != nullptr) {
    
  } else {
    
  }
  material_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), material);
  // @@protoc_insertion_point(field_set_allocated:StateMsg.material)
}

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

// JobInfoMsg

// string name = 1;
inline void JobInfoMsg::clear_name() {
  name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& JobInfoMsg::name() const {
  // @@protoc_insertion_point(field_get:JobInfoMsg.name)
  return name_.GetNoArena();
}
inline void JobInfoMsg::set_name(const std::string& value) {
  
  name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:JobInfoMsg.name)
}
inline void JobInfoMsg::set_name(std::string&& value) {
  
  name_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:JobInfoMsg.name)
}
inline void JobInfoMsg::set_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:JobInfoMsg.name)
}
inline void JobInfoMsg::set_name(const char* value, size_t size) {
  
  name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:JobInfoMsg.name)
}
inline std::string* JobInfoMsg::mutable_name() {
  
  // @@protoc_insertion_point(field_mutable:JobInfoMsg.name)
  return name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* JobInfoMsg::release_name() {
  // @@protoc_insertion_point(field_release:JobInfoMsg.name)
  
  return name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void JobInfoMsg::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    
  } else {
    
  }
  name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name);
  // @@protoc_insertion_point(field_set_allocated:JobInfoMsg.name)
}

// float xSize = 2;
inline void JobInfoMsg::clear_xsize() {
  xsize_ = 0;
}
inline float JobInfoMsg::xsize() const {
  // @@protoc_insertion_point(field_get:JobInfoMsg.xSize)
  return xsize_;
}
inline void JobInfoMsg::set_xsize(float value) {
  
  xsize_ = value;
  // @@protoc_insertion_point(field_set:JobInfoMsg.xSize)
}

// float ySize = 3;
inline void JobInfoMsg::clear_ysize() {
  ysize_ = 0;
}
inline float JobInfoMsg::ysize() const {
  // @@protoc_insertion_point(field_get:JobInfoMsg.ySize)
  return ysize_;
}
inline void JobInfoMsg::set_ysize(float value) {
  
  ysize_ = value;
  // @@protoc_insertion_point(field_set:JobInfoMsg.ySize)
}

// float zSize = 4;
inline void JobInfoMsg::clear_zsize() {
  zsize_ = 0;
}
inline float JobInfoMsg::zsize() const {
  // @@protoc_insertion_point(field_get:JobInfoMsg.zSize)
  return zsize_;
}
inline void JobInfoMsg::set_zsize(float value) {
  
  zsize_ = value;
  // @@protoc_insertion_point(field_set:JobInfoMsg.zSize)
}

// string material = 5;
inline void JobInfoMsg::clear_material() {
  material_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& JobInfoMsg::material() const {
  // @@protoc_insertion_point(field_get:JobInfoMsg.material)
  return material_.GetNoArena();
}
inline void JobInfoMsg::set_material(const std::string& value) {
  
  material_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:JobInfoMsg.material)
}
inline void JobInfoMsg::set_material(std::string&& value) {
  
  material_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:JobInfoMsg.material)
}
inline void JobInfoMsg::set_material(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  material_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:JobInfoMsg.material)
}
inline void JobInfoMsg::set_material(const char* value, size_t size) {
  
  material_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:JobInfoMsg.material)
}
inline std::string* JobInfoMsg::mutable_material() {
  
  // @@protoc_insertion_point(field_mutable:JobInfoMsg.material)
  return material_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* JobInfoMsg::release_material() {
  // @@protoc_insertion_point(field_release:JobInfoMsg.material)
  
  return material_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void JobInfoMsg::set_allocated_material(std::string* material) {
  if (material != nullptr) {
    
  } else {
    
  }
  material_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), material);
  // @@protoc_insertion_point(field_set_allocated:JobInfoMsg.material)
}

// float layerThickness = 6;
inline void JobInfoMsg::clear_layerthickness() {
  layerthickness_ = 0;
}
inline float JobInfoMsg::layerthickness() const {
  // @@protoc_insertion_point(field_get:JobInfoMsg.layerThickness)
  return layerthickness_;
}
inline void JobInfoMsg::set_layerthickness(float value) {
  
  layerthickness_ = value;
  // @@protoc_insertion_point(field_set:JobInfoMsg.layerThickness)
}

// uint32 layerCount = 7;
inline void JobInfoMsg::clear_layercount() {
  layercount_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 JobInfoMsg::layercount() const {
  // @@protoc_insertion_point(field_get:JobInfoMsg.layerCount)
  return layercount_;
}
inline void JobInfoMsg::set_layercount(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  layercount_ = value;
  // @@protoc_insertion_point(field_set:JobInfoMsg.layerCount)
}

// uint32 componentCount = 8;
inline void JobInfoMsg::clear_componentcount() {
  componentcount_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 JobInfoMsg::componentcount() const {
  // @@protoc_insertion_point(field_get:JobInfoMsg.componentCount)
  return componentcount_;
}
inline void JobInfoMsg::set_componentcount(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  componentcount_ = value;
  // @@protoc_insertion_point(field_set:JobInfoMsg.componentCount)
}

// float volume = 9;
inline void JobInfoMsg::clear_volume() {
  volume_ = 0;
}
inline float JobInfoMsg::volume() const {
  // @@protoc_insertion_point(field_get:JobInfoMsg.volume)
  return volume_;
}
inline void JobInfoMsg::set_volume(float value) {
  
  volume_ = value;
  // @@protoc_insertion_point(field_set:JobInfoMsg.volume)
}

// float supportVolume = 10;
inline void JobInfoMsg::clear_supportvolume() {
  supportvolume_ = 0;
}
inline float JobInfoMsg::supportvolume() const {
  // @@protoc_insertion_point(field_get:JobInfoMsg.supportVolume)
  return supportvolume_;
}
inline void JobInfoMsg::set_supportvolume(float value) {
  
  supportvolume_ = value;
  // @@protoc_insertion_point(field_set:JobInfoMsg.supportVolume)
}

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

// JobStateMsg

// uint64 jobId = 1;
inline void JobStateMsg::clear_jobid() {
  jobid_ = PROTOBUF_ULONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 JobStateMsg::jobid() const {
  // @@protoc_insertion_point(field_get:JobStateMsg.jobId)
  return jobid_;
}
inline void JobStateMsg::set_jobid(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  
  jobid_ = value;
  // @@protoc_insertion_point(field_set:JobStateMsg.jobId)
}

// string uId = 2;
inline void JobStateMsg::clear_uid() {
  uid_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& JobStateMsg::uid() const {
  // @@protoc_insertion_point(field_get:JobStateMsg.uId)
  return uid_.GetNoArena();
}
inline void JobStateMsg::set_uid(const std::string& value) {
  
  uid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:JobStateMsg.uId)
}
inline void JobStateMsg::set_uid(std::string&& value) {
  
  uid_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:JobStateMsg.uId)
}
inline void JobStateMsg::set_uid(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  uid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:JobStateMsg.uId)
}
inline void JobStateMsg::set_uid(const char* value, size_t size) {
  
  uid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:JobStateMsg.uId)
}
inline std::string* JobStateMsg::mutable_uid() {
  
  // @@protoc_insertion_point(field_mutable:JobStateMsg.uId)
  return uid_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* JobStateMsg::release_uid() {
  // @@protoc_insertion_point(field_release:JobStateMsg.uId)
  
  return uid_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void JobStateMsg::set_allocated_uid(std::string* uid) {
  if (uid != nullptr) {
    
  } else {
    
  }
  uid_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), uid);
  // @@protoc_insertion_point(field_set_allocated:JobStateMsg.uId)
}

// string name = 3;
inline void JobStateMsg::clear_name() {
  name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& JobStateMsg::name() const {
  // @@protoc_insertion_point(field_get:JobStateMsg.name)
  return name_.GetNoArena();
}
inline void JobStateMsg::set_name(const std::string& value) {
  
  name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:JobStateMsg.name)
}
inline void JobStateMsg::set_name(std::string&& value) {
  
  name_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:JobStateMsg.name)
}
inline void JobStateMsg::set_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:JobStateMsg.name)
}
inline void JobStateMsg::set_name(const char* value, size_t size) {
  
  name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:JobStateMsg.name)
}
inline std::string* JobStateMsg::mutable_name() {
  
  // @@protoc_insertion_point(field_mutable:JobStateMsg.name)
  return name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* JobStateMsg::release_name() {
  // @@protoc_insertion_point(field_release:JobStateMsg.name)
  
  return name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void JobStateMsg::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    
  } else {
    
  }
  name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name);
  // @@protoc_insertion_point(field_set_allocated:JobStateMsg.name)
}

// int64 startTime = 4;
inline void JobStateMsg::clear_starttime() {
  starttime_ = PROTOBUF_LONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::int64 JobStateMsg::starttime() const {
  // @@protoc_insertion_point(field_get:JobStateMsg.startTime)
  return starttime_;
}
inline void JobStateMsg::set_starttime(::PROTOBUF_NAMESPACE_ID::int64 value) {
  
  starttime_ = value;
  // @@protoc_insertion_point(field_set:JobStateMsg.startTime)
}

// int64 stopTime = 5;
inline void JobStateMsg::clear_stoptime() {
  stoptime_ = PROTOBUF_LONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::int64 JobStateMsg::stoptime() const {
  // @@protoc_insertion_point(field_get:JobStateMsg.stopTime)
  return stoptime_;
}
inline void JobStateMsg::set_stoptime(::PROTOBUF_NAMESPACE_ID::int64 value) {
  
  stoptime_ = value;
  // @@protoc_insertion_point(field_set:JobStateMsg.stopTime)
}

// uint32 deoxygenSecond = 6;
inline void JobStateMsg::clear_deoxygensecond() {
  deoxygensecond_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 JobStateMsg::deoxygensecond() const {
  // @@protoc_insertion_point(field_get:JobStateMsg.deoxygenSecond)
  return deoxygensecond_;
}
inline void JobStateMsg::set_deoxygensecond(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  deoxygensecond_ = value;
  // @@protoc_insertion_point(field_set:JobStateMsg.deoxygenSecond)
}

// uint32 spendSecond = 7;
inline void JobStateMsg::clear_spendsecond() {
  spendsecond_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 JobStateMsg::spendsecond() const {
  // @@protoc_insertion_point(field_get:JobStateMsg.spendSecond)
  return spendsecond_;
}
inline void JobStateMsg::set_spendsecond(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  spendsecond_ = value;
  // @@protoc_insertion_point(field_set:JobStateMsg.spendSecond)
}

// float moldPos = 8;
inline void JobStateMsg::clear_moldpos() {
  moldpos_ = 0;
}
inline float JobStateMsg::moldpos() const {
  // @@protoc_insertion_point(field_get:JobStateMsg.moldPos)
  return moldpos_;
}
inline void JobStateMsg::set_moldpos(float value) {
  
  moldpos_ = value;
  // @@protoc_insertion_point(field_set:JobStateMsg.moldPos)
}

// uint32 printLayerIndex = 9;
inline void JobStateMsg::clear_printlayerindex() {
  printlayerindex_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 JobStateMsg::printlayerindex() const {
  // @@protoc_insertion_point(field_get:JobStateMsg.printLayerIndex)
  return printlayerindex_;
}
inline void JobStateMsg::set_printlayerindex(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  printlayerindex_ = value;
  // @@protoc_insertion_point(field_set:JobStateMsg.printLayerIndex)
}

// bool isFinish = 10;
inline void JobStateMsg::clear_isfinish() {
  isfinish_ = false;
}
inline bool JobStateMsg::isfinish() const {
  // @@protoc_insertion_point(field_get:JobStateMsg.isFinish)
  return isfinish_;
}
inline void JobStateMsg::set_isfinish(bool value) {
  
  isfinish_ = value;
  // @@protoc_insertion_point(field_set:JobStateMsg.isFinish)
}

// bool isContinue = 11;
inline void JobStateMsg::clear_iscontinue() {
  iscontinue_ = false;
}
inline bool JobStateMsg::iscontinue() const {
  // @@protoc_insertion_point(field_get:JobStateMsg.isContinue)
  return iscontinue_;
}
inline void JobStateMsg::set_iscontinue(bool value) {
  
  iscontinue_ = value;
  // @@protoc_insertion_point(field_set:JobStateMsg.isContinue)
}

// bool isInvalid = 12;
inline void JobStateMsg::clear_isinvalid() {
  isinvalid_ = false;
}
inline bool JobStateMsg::isinvalid() const {
  // @@protoc_insertion_point(field_get:JobStateMsg.isInvalid)
  return isinvalid_;
}
inline void JobStateMsg::set_isinvalid(bool value) {
  
  isinvalid_ = value;
  // @@protoc_insertion_point(field_set:JobStateMsg.isInvalid)
}

// .JobStateMsg.JobState jobState = 13;
inline void JobStateMsg::clear_jobstate() {
  jobstate_ = 0;
}
inline ::JobStateMsg_JobState JobStateMsg::jobstate() const {
  // @@protoc_insertion_point(field_get:JobStateMsg.jobState)
  return static_cast< ::JobStateMsg_JobState >(jobstate_);
}
inline void JobStateMsg::set_jobstate(::JobStateMsg_JobState value) {
  
  jobstate_ = value;
  // @@protoc_insertion_point(field_set:JobStateMsg.jobState)
}

// string machineId = 14;
inline void JobStateMsg::clear_machineid() {
  machineid_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& JobStateMsg::machineid() const {
  // @@protoc_insertion_point(field_get:JobStateMsg.machineId)
  return machineid_.GetNoArena();
}
inline void JobStateMsg::set_machineid(const std::string& value) {
  
  machineid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:JobStateMsg.machineId)
}
inline void JobStateMsg::set_machineid(std::string&& value) {
  
  machineid_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:JobStateMsg.machineId)
}
inline void JobStateMsg::set_machineid(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  machineid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:JobStateMsg.machineId)
}
inline void JobStateMsg::set_machineid(const char* value, size_t size) {
  
  machineid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:JobStateMsg.machineId)
}
inline std::string* JobStateMsg::mutable_machineid() {
  
  // @@protoc_insertion_point(field_mutable:JobStateMsg.machineId)
  return machineid_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* JobStateMsg::release_machineid() {
  // @@protoc_insertion_point(field_release:JobStateMsg.machineId)
  
  return machineid_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void JobStateMsg::set_allocated_machineid(std::string* machineid) {
  if (machineid != nullptr) {
    
  } else {
    
  }
  machineid_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), machineid);
  // @@protoc_insertion_point(field_set_allocated:JobStateMsg.machineId)
}

// .JobInfoMsg jobInfo = 15;
inline bool JobStateMsg::has_jobinfo() const {
  return this != internal_default_instance() && jobinfo_ != nullptr;
}
inline void JobStateMsg::clear_jobinfo() {
  if (GetArenaNoVirtual() == nullptr && jobinfo_ != nullptr) {
    delete jobinfo_;
  }
  jobinfo_ = nullptr;
}
inline const ::JobInfoMsg& JobStateMsg::jobinfo() const {
  const ::JobInfoMsg* p = jobinfo_;
  // @@protoc_insertion_point(field_get:JobStateMsg.jobInfo)
  return p != nullptr ? *p : *reinterpret_cast<const ::JobInfoMsg*>(
      &::_JobInfoMsg_default_instance_);
}
inline ::JobInfoMsg* JobStateMsg::release_jobinfo() {
  // @@protoc_insertion_point(field_release:JobStateMsg.jobInfo)
  
  ::JobInfoMsg* temp = jobinfo_;
  jobinfo_ = nullptr;
  return temp;
}
inline ::JobInfoMsg* JobStateMsg::mutable_jobinfo() {
  
  if (jobinfo_ == nullptr) {
    auto* p = CreateMaybeMessage<::JobInfoMsg>(GetArenaNoVirtual());
    jobinfo_ = p;
  }
  // @@protoc_insertion_point(field_mutable:JobStateMsg.jobInfo)
  return jobinfo_;
}
inline void JobStateMsg::set_allocated_jobinfo(::JobInfoMsg* jobinfo) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete jobinfo_;
  }
  if (jobinfo) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      jobinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, jobinfo, submessage_arena);
    }
    
  } else {
    
  }
  jobinfo_ = jobinfo;
  // @@protoc_insertion_point(field_set_allocated:JobStateMsg.jobInfo)
}

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

// MachineMsg

// string machineId = 1;
inline void MachineMsg::clear_machineid() {
  machineid_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& MachineMsg::machineid() const {
  // @@protoc_insertion_point(field_get:MachineMsg.machineId)
  return machineid_.GetNoArena();
}
inline void MachineMsg::set_machineid(const std::string& value) {
  
  machineid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:MachineMsg.machineId)
}
inline void MachineMsg::set_machineid(std::string&& value) {
  
  machineid_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:MachineMsg.machineId)
}
inline void MachineMsg::set_machineid(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  machineid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:MachineMsg.machineId)
}
inline void MachineMsg::set_machineid(const char* value, size_t size) {
  
  machineid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:MachineMsg.machineId)
}
inline std::string* MachineMsg::mutable_machineid() {
  
  // @@protoc_insertion_point(field_mutable:MachineMsg.machineId)
  return machineid_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* MachineMsg::release_machineid() {
  // @@protoc_insertion_point(field_release:MachineMsg.machineId)
  
  return machineid_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void MachineMsg::set_allocated_machineid(std::string* machineid) {
  if (machineid != nullptr) {
    
  } else {
    
  }
  machineid_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), machineid);
  // @@protoc_insertion_point(field_set_allocated:MachineMsg.machineId)
}

// .MachineMsg.MachineType machineType = 2;
inline void MachineMsg::clear_machinetype() {
  machinetype_ = 0;
}
inline ::MachineMsg_MachineType MachineMsg::machinetype() const {
  // @@protoc_insertion_point(field_get:MachineMsg.machineType)
  return static_cast< ::MachineMsg_MachineType >(machinetype_);
}
inline void MachineMsg::set_machinetype(::MachineMsg_MachineType value) {
  
  machinetype_ = value;
  // @@protoc_insertion_point(field_set:MachineMsg.machineType)
}

// .MachineMsg.PurifierType purifierType = 3;
inline void MachineMsg::clear_purifiertype() {
  purifiertype_ = 0;
}
inline ::MachineMsg_PurifierType MachineMsg::purifiertype() const {
  // @@protoc_insertion_point(field_get:MachineMsg.purifierType)
  return static_cast< ::MachineMsg_PurifierType >(purifiertype_);
}
inline void MachineMsg::set_purifiertype(::MachineMsg_PurifierType value) {
  
  purifiertype_ = value;
  // @@protoc_insertion_point(field_set:MachineMsg.purifierType)
}

// int64 lastStartTime = 4;
inline void MachineMsg::clear_laststarttime() {
  laststarttime_ = PROTOBUF_LONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::int64 MachineMsg::laststarttime() const {
  // @@protoc_insertion_point(field_get:MachineMsg.lastStartTime)
  return laststarttime_;
}
inline void MachineMsg::set_laststarttime(::PROTOBUF_NAMESPACE_ID::int64 value) {
  
  laststarttime_ = value;
  // @@protoc_insertion_point(field_set:MachineMsg.lastStartTime)
}

// int64 lastShutdownTime = 5;
inline void MachineMsg::clear_lastshutdowntime() {
  lastshutdowntime_ = PROTOBUF_LONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::int64 MachineMsg::lastshutdowntime() const {
  // @@protoc_insertion_point(field_get:MachineMsg.lastShutdownTime)
  return lastshutdowntime_;
}
inline void MachineMsg::set_lastshutdowntime(::PROTOBUF_NAMESPACE_ID::int64 value) {
  
  lastshutdowntime_ = value;
  // @@protoc_insertion_point(field_set:MachineMsg.lastShutdownTime)
}

// int32 language = 6;
inline void MachineMsg::clear_language() {
  language_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 MachineMsg::language() const {
  // @@protoc_insertion_point(field_get:MachineMsg.language)
  return language_;
}
inline void MachineMsg::set_language(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  language_ = value;
  // @@protoc_insertion_point(field_set:MachineMsg.language)
}

// bool isOnline = 7;
inline void MachineMsg::clear_isonline() {
  isonline_ = false;
}
inline bool MachineMsg::isonline() const {
  // @@protoc_insertion_point(field_get:MachineMsg.isOnline)
  return isonline_;
}
inline void MachineMsg::set_isonline(bool value) {
  
  isonline_ = value;
  // @@protoc_insertion_point(field_set:MachineMsg.isOnline)
}

// string password = 8;
inline void MachineMsg::clear_password() {
  password_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& MachineMsg::password() const {
  // @@protoc_insertion_point(field_get:MachineMsg.password)
  return password_.GetNoArena();
}
inline void MachineMsg::set_password(const std::string& value) {
  
  password_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:MachineMsg.password)
}
inline void MachineMsg::set_password(std::string&& value) {
  
  password_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:MachineMsg.password)
}
inline void MachineMsg::set_password(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  password_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:MachineMsg.password)
}
inline void MachineMsg::set_password(const char* value, size_t size) {
  
  password_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:MachineMsg.password)
}
inline std::string* MachineMsg::mutable_password() {
  
  // @@protoc_insertion_point(field_mutable:MachineMsg.password)
  return password_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* MachineMsg::release_password() {
  // @@protoc_insertion_point(field_release:MachineMsg.password)
  
  return password_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void MachineMsg::set_allocated_password(std::string* password) {
  if (password != nullptr) {
    
  } else {
    
  }
  password_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), password);
  // @@protoc_insertion_point(field_set_allocated:MachineMsg.password)
}

// string name = 9;
inline void MachineMsg::clear_name() {
  name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& MachineMsg::name() const {
  // @@protoc_insertion_point(field_get:MachineMsg.name)
  return name_.GetNoArena();
}
inline void MachineMsg::set_name(const std::string& value) {
  
  name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:MachineMsg.name)
}
inline void MachineMsg::set_name(std::string&& value) {
  
  name_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:MachineMsg.name)
}
inline void MachineMsg::set_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:MachineMsg.name)
}
inline void MachineMsg::set_name(const char* value, size_t size) {
  
  name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:MachineMsg.name)
}
inline std::string* MachineMsg::mutable_name() {
  
  // @@protoc_insertion_point(field_mutable:MachineMsg.name)
  return name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* MachineMsg::release_name() {
  // @@protoc_insertion_point(field_release:MachineMsg.name)
  
  return name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void MachineMsg::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    
  } else {
    
  }
  name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name);
  // @@protoc_insertion_point(field_set_allocated:MachineMsg.name)
}

// string location = 10;
inline void MachineMsg::clear_location() {
  location_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& MachineMsg::location() const {
  // @@protoc_insertion_point(field_get:MachineMsg.location)
  return location_.GetNoArena();
}
inline void MachineMsg::set_location(const std::string& value) {
  
  location_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:MachineMsg.location)
}
inline void MachineMsg::set_location(std::string&& value) {
  
  location_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:MachineMsg.location)
}
inline void MachineMsg::set_location(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  location_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:MachineMsg.location)
}
inline void MachineMsg::set_location(const char* value, size_t size) {
  
  location_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:MachineMsg.location)
}
inline std::string* MachineMsg::mutable_location() {
  
  // @@protoc_insertion_point(field_mutable:MachineMsg.location)
  return location_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* MachineMsg::release_location() {
  // @@protoc_insertion_point(field_release:MachineMsg.location)
  
  return location_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void MachineMsg::set_allocated_location(std::string* location) {
  if (location != nullptr) {
    
  } else {
    
  }
  location_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), location);
  // @@protoc_insertion_point(field_set_allocated:MachineMsg.location)
}

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

// ErrorMsg

// .ErrorMsg.ErrorType errorType = 1;
inline void ErrorMsg::clear_errortype() {
  errortype_ = 0;
}
inline ::ErrorMsg_ErrorType ErrorMsg::errortype() const {
  // @@protoc_insertion_point(field_get:ErrorMsg.errorType)
  return static_cast< ::ErrorMsg_ErrorType >(errortype_);
}
inline void ErrorMsg::set_errortype(::ErrorMsg_ErrorType value) {
  
  errortype_ = value;
  // @@protoc_insertion_point(field_set:ErrorMsg.errorType)
}

// string errorMsg = 2;
inline void ErrorMsg::clear_errormsg() {
  errormsg_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& ErrorMsg::errormsg() const {
  // @@protoc_insertion_point(field_get:ErrorMsg.errorMsg)
  return errormsg_.GetNoArena();
}
inline void ErrorMsg::set_errormsg(const std::string& value) {
  
  errormsg_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:ErrorMsg.errorMsg)
}
inline void ErrorMsg::set_errormsg(std::string&& value) {
  
  errormsg_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:ErrorMsg.errorMsg)
}
inline void ErrorMsg::set_errormsg(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  errormsg_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:ErrorMsg.errorMsg)
}
inline void ErrorMsg::set_errormsg(const char* value, size_t size) {
  
  errormsg_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:ErrorMsg.errorMsg)
}
inline std::string* ErrorMsg::mutable_errormsg() {
  
  // @@protoc_insertion_point(field_mutable:ErrorMsg.errorMsg)
  return errormsg_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* ErrorMsg::release_errormsg() {
  // @@protoc_insertion_point(field_release:ErrorMsg.errorMsg)
  
  return errormsg_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void ErrorMsg::set_allocated_errormsg(std::string* errormsg) {
  if (errormsg != nullptr) {
    
  } else {
    
  }
  errormsg_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), errormsg);
  // @@protoc_insertion_point(field_set_allocated:ErrorMsg.errorMsg)
}

// int64 occurTime = 3;
inline void ErrorMsg::clear_occurtime() {
  occurtime_ = PROTOBUF_LONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::int64 ErrorMsg::occurtime() const {
  // @@protoc_insertion_point(field_get:ErrorMsg.occurTime)
  return occurtime_;
}
inline void ErrorMsg::set_occurtime(::PROTOBUF_NAMESPACE_ID::int64 value) {
  
  occurtime_ = value;
  // @@protoc_insertion_point(field_set:ErrorMsg.occurTime)
}

// string machineId = 4;
inline void ErrorMsg::clear_machineid() {
  machineid_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& ErrorMsg::machineid() const {
  // @@protoc_insertion_point(field_get:ErrorMsg.machineId)
  return machineid_.GetNoArena();
}
inline void ErrorMsg::set_machineid(const std::string& value) {
  
  machineid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:ErrorMsg.machineId)
}
inline void ErrorMsg::set_machineid(std::string&& value) {
  
  machineid_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:ErrorMsg.machineId)
}
inline void ErrorMsg::set_machineid(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  machineid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:ErrorMsg.machineId)
}
inline void ErrorMsg::set_machineid(const char* value, size_t size) {
  
  machineid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:ErrorMsg.machineId)
}
inline std::string* ErrorMsg::mutable_machineid() {
  
  // @@protoc_insertion_point(field_mutable:ErrorMsg.machineId)
  return machineid_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* ErrorMsg::release_machineid() {
  // @@protoc_insertion_point(field_release:ErrorMsg.machineId)
  
  return machineid_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void ErrorMsg::set_allocated_machineid(std::string* machineid) {
  if (machineid != nullptr) {
    
  } else {
    
  }
  machineid_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), machineid);
  // @@protoc_insertion_point(field_set_allocated:ErrorMsg.machineId)
}

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

// ParameterMsg

// string type = 1;
inline void ParameterMsg::clear_type() {
  type_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& ParameterMsg::type() const {
  // @@protoc_insertion_point(field_get:ParameterMsg.type)
  return type_.GetNoArena();
}
inline void ParameterMsg::set_type(const std::string& value) {
  
  type_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:ParameterMsg.type)
}
inline void ParameterMsg::set_type(std::string&& value) {
  
  type_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:ParameterMsg.type)
}
inline void ParameterMsg::set_type(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  type_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:ParameterMsg.type)
}
inline void ParameterMsg::set_type(const char* value, size_t size) {
  
  type_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:ParameterMsg.type)
}
inline std::string* ParameterMsg::mutable_type() {
  
  // @@protoc_insertion_point(field_mutable:ParameterMsg.type)
  return type_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* ParameterMsg::release_type() {
  // @@protoc_insertion_point(field_release:ParameterMsg.type)
  
  return type_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void ParameterMsg::set_allocated_type(std::string* type) {
  if (type != nullptr) {
    
  } else {
    
  }
  type_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), type);
  // @@protoc_insertion_point(field_set_allocated:ParameterMsg.type)
}

// float laserSpeed = 2;
inline void ParameterMsg::clear_laserspeed() {
  laserspeed_ = 0;
}
inline float ParameterMsg::laserspeed() const {
  // @@protoc_insertion_point(field_get:ParameterMsg.laserSpeed)
  return laserspeed_;
}
inline void ParameterMsg::set_laserspeed(float value) {
  
  laserspeed_ = value;
  // @@protoc_insertion_point(field_set:ParameterMsg.laserSpeed)
}

// float laserPower = 3;
inline void ParameterMsg::clear_laserpower() {
  laserpower_ = 0;
}
inline float ParameterMsg::laserpower() const {
  // @@protoc_insertion_point(field_get:ParameterMsg.laserPower)
  return laserpower_;
}
inline void ParameterMsg::set_laserpower(float value) {
  
  laserpower_ = value;
  // @@protoc_insertion_point(field_set:ParameterMsg.laserPower)
}

// float laserDiameter = 4;
inline void ParameterMsg::clear_laserdiameter() {
  laserdiameter_ = 0;
}
inline float ParameterMsg::laserdiameter() const {
  // @@protoc_insertion_point(field_get:ParameterMsg.laserDiameter)
  return laserdiameter_;
}
inline void ParameterMsg::set_laserdiameter(float value) {
  
  laserdiameter_ = value;
  // @@protoc_insertion_point(field_set:ParameterMsg.laserDiameter)
}

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

// PartMsg

// string name = 1;
inline void PartMsg::clear_name() {
  name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& PartMsg::name() const {
  // @@protoc_insertion_point(field_get:PartMsg.name)
  return name_.GetNoArena();
}
inline void PartMsg::set_name(const std::string& value) {
  
  name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:PartMsg.name)
}
inline void PartMsg::set_name(std::string&& value) {
  
  name_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:PartMsg.name)
}
inline void PartMsg::set_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:PartMsg.name)
}
inline void PartMsg::set_name(const char* value, size_t size) {
  
  name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:PartMsg.name)
}
inline std::string* PartMsg::mutable_name() {
  
  // @@protoc_insertion_point(field_mutable:PartMsg.name)
  return name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* PartMsg::release_name() {
  // @@protoc_insertion_point(field_release:PartMsg.name)
  
  return name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void PartMsg::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    
  } else {
    
  }
  name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name);
  // @@protoc_insertion_point(field_set_allocated:PartMsg.name)
}

// repeated .ParameterMsg param = 2;
inline int PartMsg::param_size() const {
  return param_.size();
}
inline void PartMsg::clear_param() {
  param_.Clear();
}
inline ::ParameterMsg* PartMsg::mutable_param(int index) {
  // @@protoc_insertion_point(field_mutable:PartMsg.param)
  return param_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::ParameterMsg >*
PartMsg::mutable_param() {
  // @@protoc_insertion_point(field_mutable_list:PartMsg.param)
  return &param_;
}
inline const ::ParameterMsg& PartMsg::param(int index) const {
  // @@protoc_insertion_point(field_get:PartMsg.param)
  return param_.Get(index);
}
inline ::ParameterMsg* PartMsg::add_param() {
  // @@protoc_insertion_point(field_add:PartMsg.param)
  return param_.Add();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::ParameterMsg >&
PartMsg::param() const {
  // @@protoc_insertion_point(field_list:PartMsg.param)
  return param_;
}

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

// JobMsg

// .JobInfoMsg jobInfoMsg = 1;
inline bool JobMsg::has_jobinfomsg() const {
  return this != internal_default_instance() && jobinfomsg_ != nullptr;
}
inline void JobMsg::clear_jobinfomsg() {
  if (GetArenaNoVirtual() == nullptr && jobinfomsg_ != nullptr) {
    delete jobinfomsg_;
  }
  jobinfomsg_ = nullptr;
}
inline const ::JobInfoMsg& JobMsg::jobinfomsg() const {
  const ::JobInfoMsg* p = jobinfomsg_;
  // @@protoc_insertion_point(field_get:JobMsg.jobInfoMsg)
  return p != nullptr ? *p : *reinterpret_cast<const ::JobInfoMsg*>(
      &::_JobInfoMsg_default_instance_);
}
inline ::JobInfoMsg* JobMsg::release_jobinfomsg() {
  // @@protoc_insertion_point(field_release:JobMsg.jobInfoMsg)
  
  ::JobInfoMsg* temp = jobinfomsg_;
  jobinfomsg_ = nullptr;
  return temp;
}
inline ::JobInfoMsg* JobMsg::mutable_jobinfomsg() {
  
  if (jobinfomsg_ == nullptr) {
    auto* p = CreateMaybeMessage<::JobInfoMsg>(GetArenaNoVirtual());
    jobinfomsg_ = p;
  }
  // @@protoc_insertion_point(field_mutable:JobMsg.jobInfoMsg)
  return jobinfomsg_;
}
inline void JobMsg::set_allocated_jobinfomsg(::JobInfoMsg* jobinfomsg) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete jobinfomsg_;
  }
  if (jobinfomsg) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      jobinfomsg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, jobinfomsg, submessage_arena);
    }
    
  } else {
    
  }
  jobinfomsg_ = jobinfomsg;
  // @@protoc_insertion_point(field_set_allocated:JobMsg.jobInfoMsg)
}

// repeated .PartMsg partMsg = 2;
inline int JobMsg::partmsg_size() const {
  return partmsg_.size();
}
inline void JobMsg::clear_partmsg() {
  partmsg_.Clear();
}
inline ::PartMsg* JobMsg::mutable_partmsg(int index) {
  // @@protoc_insertion_point(field_mutable:JobMsg.partMsg)
  return partmsg_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PartMsg >*
JobMsg::mutable_partmsg() {
  // @@protoc_insertion_point(field_mutable_list:JobMsg.partMsg)
  return &partmsg_;
}
inline const ::PartMsg& JobMsg::partmsg(int index) const {
  // @@protoc_insertion_point(field_get:JobMsg.partMsg)
  return partmsg_.Get(index);
}
inline ::PartMsg* JobMsg::add_partmsg() {
  // @@protoc_insertion_point(field_add:JobMsg.partMsg)
  return partmsg_.Add();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PartMsg >&
JobMsg::partmsg() const {
  // @@protoc_insertion_point(field_list:JobMsg.partMsg)
  return partmsg_;
}

// string machineId = 3;
inline void JobMsg::clear_machineid() {
  machineid_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& JobMsg::machineid() const {
  // @@protoc_insertion_point(field_get:JobMsg.machineId)
  return machineid_.GetNoArena();
}
inline void JobMsg::set_machineid(const std::string& value) {
  
  machineid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:JobMsg.machineId)
}
inline void JobMsg::set_machineid(std::string&& value) {
  
  machineid_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:JobMsg.machineId)
}
inline void JobMsg::set_machineid(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  machineid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:JobMsg.machineId)
}
inline void JobMsg::set_machineid(const char* value, size_t size) {
  
  machineid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:JobMsg.machineId)
}
inline std::string* JobMsg::mutable_machineid() {
  
  // @@protoc_insertion_point(field_mutable:JobMsg.machineId)
  return machineid_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* JobMsg::release_machineid() {
  // @@protoc_insertion_point(field_release:JobMsg.machineId)
  
  return machineid_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void JobMsg::set_allocated_machineid(std::string* machineid) {
  if (machineid != nullptr) {
    
  } else {
    
  }
  machineid_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), machineid);
  // @@protoc_insertion_point(field_set_allocated:JobMsg.machineId)
}

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

// LayerDataRespMsg

// string machineId = 1;
inline void LayerDataRespMsg::clear_machineid() {
  machineid_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& LayerDataRespMsg::machineid() const {
  // @@protoc_insertion_point(field_get:LayerDataRespMsg.machineId)
  return machineid_.GetNoArena();
}
inline void LayerDataRespMsg::set_machineid(const std::string& value) {
  
  machineid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:LayerDataRespMsg.machineId)
}
inline void LayerDataRespMsg::set_machineid(std::string&& value) {
  
  machineid_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:LayerDataRespMsg.machineId)
}
inline void LayerDataRespMsg::set_machineid(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  machineid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:LayerDataRespMsg.machineId)
}
inline void LayerDataRespMsg::set_machineid(const char* value, size_t size) {
  
  machineid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:LayerDataRespMsg.machineId)
}
inline std::string* LayerDataRespMsg::mutable_machineid() {
  
  // @@protoc_insertion_point(field_mutable:LayerDataRespMsg.machineId)
  return machineid_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* LayerDataRespMsg::release_machineid() {
  // @@protoc_insertion_point(field_release:LayerDataRespMsg.machineId)
  
  return machineid_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void LayerDataRespMsg::set_allocated_machineid(std::string* machineid) {
  if (machineid != nullptr) {
    
  } else {
    
  }
  machineid_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), machineid);
  // @@protoc_insertion_point(field_set_allocated:LayerDataRespMsg.machineId)
}

// int32 type = 2;
inline void LayerDataRespMsg::clear_type() {
  type_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 LayerDataRespMsg::type() const {
  // @@protoc_insertion_point(field_get:LayerDataRespMsg.type)
  return type_;
}
inline void LayerDataRespMsg::set_type(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  type_ = value;
  // @@protoc_insertion_point(field_set:LayerDataRespMsg.type)
}

// int32 partId = 3;
inline void LayerDataRespMsg::clear_partid() {
  partid_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 LayerDataRespMsg::partid() const {
  // @@protoc_insertion_point(field_get:LayerDataRespMsg.partId)
  return partid_;
}
inline void LayerDataRespMsg::set_partid(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  partid_ = value;
  // @@protoc_insertion_point(field_set:LayerDataRespMsg.partId)
}

// uint32 total = 4;
inline void LayerDataRespMsg::clear_total() {
  total_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 LayerDataRespMsg::total() const {
  // @@protoc_insertion_point(field_get:LayerDataRespMsg.total)
  return total_;
}
inline void LayerDataRespMsg::set_total(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  total_ = value;
  // @@protoc_insertion_point(field_set:LayerDataRespMsg.total)
}

// uint32 index = 5;
inline void LayerDataRespMsg::clear_index() {
  index_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 LayerDataRespMsg::index() const {
  // @@protoc_insertion_point(field_get:LayerDataRespMsg.index)
  return index_;
}
inline void LayerDataRespMsg::set_index(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  index_ = value;
  // @@protoc_insertion_point(field_set:LayerDataRespMsg.index)
}

// repeated float data = 6;
inline int LayerDataRespMsg::data_size() const {
  return data_.size();
}
inline void LayerDataRespMsg::clear_data() {
  data_.Clear();
}
inline float LayerDataRespMsg::data(int index) const {
  // @@protoc_insertion_point(field_get:LayerDataRespMsg.data)
  return data_.Get(index);
}
inline void LayerDataRespMsg::set_data(int index, float value) {
  data_.Set(index, value);
  // @@protoc_insertion_point(field_set:LayerDataRespMsg.data)
}
inline void LayerDataRespMsg::add_data(float value) {
  data_.Add(value);
  // @@protoc_insertion_point(field_add:LayerDataRespMsg.data)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
LayerDataRespMsg::data() const {
  // @@protoc_insertion_point(field_list:LayerDataRespMsg.data)
  return data_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
LayerDataRespMsg::mutable_data() {
  // @@protoc_insertion_point(field_mutable_list:LayerDataRespMsg.data)
  return &data_;
}

// bytes datas = 7;
inline void LayerDataRespMsg::clear_datas() {
  datas_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& LayerDataRespMsg::datas() const {
  // @@protoc_insertion_point(field_get:LayerDataRespMsg.datas)
  return datas_.GetNoArena();
}
inline void LayerDataRespMsg::set_datas(const std::string& value) {
  
  datas_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:LayerDataRespMsg.datas)
}
inline void LayerDataRespMsg::set_datas(std::string&& value) {
  
  datas_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:LayerDataRespMsg.datas)
}
inline void LayerDataRespMsg::set_datas(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  datas_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:LayerDataRespMsg.datas)
}
inline void LayerDataRespMsg::set_datas(const void* value, size_t size) {
  
  datas_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:LayerDataRespMsg.datas)
}
inline std::string* LayerDataRespMsg::mutable_datas() {
  
  // @@protoc_insertion_point(field_mutable:LayerDataRespMsg.datas)
  return datas_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* LayerDataRespMsg::release_datas() {
  // @@protoc_insertion_point(field_release:LayerDataRespMsg.datas)
  
  return datas_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void LayerDataRespMsg::set_allocated_datas(std::string* datas) {
  if (datas != nullptr) {
    
  } else {
    
  }
  datas_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), datas);
  // @@protoc_insertion_point(field_set_allocated:LayerDataRespMsg.datas)
}

// string paramType = 8;
inline void LayerDataRespMsg::clear_paramtype() {
  paramtype_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& LayerDataRespMsg::paramtype() const {
  // @@protoc_insertion_point(field_get:LayerDataRespMsg.paramType)
  return paramtype_.GetNoArena();
}
inline void LayerDataRespMsg::set_paramtype(const std::string& value) {
  
  paramtype_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:LayerDataRespMsg.paramType)
}
inline void LayerDataRespMsg::set_paramtype(std::string&& value) {
  
  paramtype_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:LayerDataRespMsg.paramType)
}
inline void LayerDataRespMsg::set_paramtype(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  paramtype_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:LayerDataRespMsg.paramType)
}
inline void LayerDataRespMsg::set_paramtype(const char* value, size_t size) {
  
  paramtype_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:LayerDataRespMsg.paramType)
}
inline std::string* LayerDataRespMsg::mutable_paramtype() {
  
  // @@protoc_insertion_point(field_mutable:LayerDataRespMsg.paramType)
  return paramtype_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* LayerDataRespMsg::release_paramtype() {
  // @@protoc_insertion_point(field_release:LayerDataRespMsg.paramType)
  
  return paramtype_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void LayerDataRespMsg::set_allocated_paramtype(std::string* paramtype) {
  if (paramtype != nullptr) {
    
  } else {
    
  }
  paramtype_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), paramtype);
  // @@protoc_insertion_point(field_set_allocated:LayerDataRespMsg.paramType)
}

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

// DataBlockMsg

// int32 type = 1;
inline void DataBlockMsg::clear_type() {
  type_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 DataBlockMsg::type() const {
  // @@protoc_insertion_point(field_get:DataBlockMsg.type)
  return type_;
}
inline void DataBlockMsg::set_type(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  type_ = value;
  // @@protoc_insertion_point(field_set:DataBlockMsg.type)
}

// repeated float data = 2;
inline int DataBlockMsg::data_size() const {
  return data_.size();
}
inline void DataBlockMsg::clear_data() {
  data_.Clear();
}
inline float DataBlockMsg::data(int index) const {
  // @@protoc_insertion_point(field_get:DataBlockMsg.data)
  return data_.Get(index);
}
inline void DataBlockMsg::set_data(int index, float value) {
  data_.Set(index, value);
  // @@protoc_insertion_point(field_set:DataBlockMsg.data)
}
inline void DataBlockMsg::add_data(float value) {
  data_.Add(value);
  // @@protoc_insertion_point(field_add:DataBlockMsg.data)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
DataBlockMsg::data() const {
  // @@protoc_insertion_point(field_list:DataBlockMsg.data)
  return data_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
DataBlockMsg::mutable_data() {
  // @@protoc_insertion_point(field_mutable_list:DataBlockMsg.data)
  return &data_;
}

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

// LayerDataBlockMsg

// string machineId = 1;
inline void LayerDataBlockMsg::clear_machineid() {
  machineid_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& LayerDataBlockMsg::machineid() const {
  // @@protoc_insertion_point(field_get:LayerDataBlockMsg.machineId)
  return machineid_.GetNoArena();
}
inline void LayerDataBlockMsg::set_machineid(const std::string& value) {
  
  machineid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:LayerDataBlockMsg.machineId)
}
inline void LayerDataBlockMsg::set_machineid(std::string&& value) {
  
  machineid_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:LayerDataBlockMsg.machineId)
}
inline void LayerDataBlockMsg::set_machineid(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  machineid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:LayerDataBlockMsg.machineId)
}
inline void LayerDataBlockMsg::set_machineid(const char* value, size_t size) {
  
  machineid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:LayerDataBlockMsg.machineId)
}
inline std::string* LayerDataBlockMsg::mutable_machineid() {
  
  // @@protoc_insertion_point(field_mutable:LayerDataBlockMsg.machineId)
  return machineid_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* LayerDataBlockMsg::release_machineid() {
  // @@protoc_insertion_point(field_release:LayerDataBlockMsg.machineId)
  
  return machineid_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void LayerDataBlockMsg::set_allocated_machineid(std::string* machineid) {
  if (machineid != nullptr) {
    
  } else {
    
  }
  machineid_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), machineid);
  // @@protoc_insertion_point(field_set_allocated:LayerDataBlockMsg.machineId)
}

// string jobName = 2;
inline void LayerDataBlockMsg::clear_jobname() {
  jobname_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& LayerDataBlockMsg::jobname() const {
  // @@protoc_insertion_point(field_get:LayerDataBlockMsg.jobName)
  return jobname_.GetNoArena();
}
inline void LayerDataBlockMsg::set_jobname(const std::string& value) {
  
  jobname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:LayerDataBlockMsg.jobName)
}
inline void LayerDataBlockMsg::set_jobname(std::string&& value) {
  
  jobname_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:LayerDataBlockMsg.jobName)
}
inline void LayerDataBlockMsg::set_jobname(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  jobname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:LayerDataBlockMsg.jobName)
}
inline void LayerDataBlockMsg::set_jobname(const char* value, size_t size) {
  
  jobname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:LayerDataBlockMsg.jobName)
}
inline std::string* LayerDataBlockMsg::mutable_jobname() {
  
  // @@protoc_insertion_point(field_mutable:LayerDataBlockMsg.jobName)
  return jobname_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* LayerDataBlockMsg::release_jobname() {
  // @@protoc_insertion_point(field_release:LayerDataBlockMsg.jobName)
  
  return jobname_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void LayerDataBlockMsg::set_allocated_jobname(std::string* jobname) {
  if (jobname != nullptr) {
    
  } else {
    
  }
  jobname_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), jobname);
  // @@protoc_insertion_point(field_set_allocated:LayerDataBlockMsg.jobName)
}

// string jobUid = 3;
inline void LayerDataBlockMsg::clear_jobuid() {
  jobuid_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& LayerDataBlockMsg::jobuid() const {
  // @@protoc_insertion_point(field_get:LayerDataBlockMsg.jobUid)
  return jobuid_.GetNoArena();
}
inline void LayerDataBlockMsg::set_jobuid(const std::string& value) {
  
  jobuid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:LayerDataBlockMsg.jobUid)
}
inline void LayerDataBlockMsg::set_jobuid(std::string&& value) {
  
  jobuid_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:LayerDataBlockMsg.jobUid)
}
inline void LayerDataBlockMsg::set_jobuid(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  jobuid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:LayerDataBlockMsg.jobUid)
}
inline void LayerDataBlockMsg::set_jobuid(const char* value, size_t size) {
  
  jobuid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:LayerDataBlockMsg.jobUid)
}
inline std::string* LayerDataBlockMsg::mutable_jobuid() {
  
  // @@protoc_insertion_point(field_mutable:LayerDataBlockMsg.jobUid)
  return jobuid_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* LayerDataBlockMsg::release_jobuid() {
  // @@protoc_insertion_point(field_release:LayerDataBlockMsg.jobUid)
  
  return jobuid_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void LayerDataBlockMsg::set_allocated_jobuid(std::string* jobuid) {
  if (jobuid != nullptr) {
    
  } else {
    
  }
  jobuid_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), jobuid);
  // @@protoc_insertion_point(field_set_allocated:LayerDataBlockMsg.jobUid)
}

// uint32 layerCount = 4;
inline void LayerDataBlockMsg::clear_layercount() {
  layercount_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 LayerDataBlockMsg::layercount() const {
  // @@protoc_insertion_point(field_get:LayerDataBlockMsg.layerCount)
  return layercount_;
}
inline void LayerDataBlockMsg::set_layercount(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  layercount_ = value;
  // @@protoc_insertion_point(field_set:LayerDataBlockMsg.layerCount)
}

// float thickness = 5;
inline void LayerDataBlockMsg::clear_thickness() {
  thickness_ = 0;
}
inline float LayerDataBlockMsg::thickness() const {
  // @@protoc_insertion_point(field_get:LayerDataBlockMsg.thickness)
  return thickness_;
}
inline void LayerDataBlockMsg::set_thickness(float value) {
  
  thickness_ = value;
  // @@protoc_insertion_point(field_set:LayerDataBlockMsg.thickness)
}

// uint32 layerIndex = 6;
inline void LayerDataBlockMsg::clear_layerindex() {
  layerindex_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 LayerDataBlockMsg::layerindex() const {
  // @@protoc_insertion_point(field_get:LayerDataBlockMsg.layerIndex)
  return layerindex_;
}
inline void LayerDataBlockMsg::set_layerindex(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  layerindex_ = value;
  // @@protoc_insertion_point(field_set:LayerDataBlockMsg.layerIndex)
}

// repeated .DataBlockMsg dataBlocks = 7;
inline int LayerDataBlockMsg::datablocks_size() const {
  return datablocks_.size();
}
inline void LayerDataBlockMsg::clear_datablocks() {
  datablocks_.Clear();
}
inline ::DataBlockMsg* LayerDataBlockMsg::mutable_datablocks(int index) {
  // @@protoc_insertion_point(field_mutable:LayerDataBlockMsg.dataBlocks)
  return datablocks_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::DataBlockMsg >*
LayerDataBlockMsg::mutable_datablocks() {
  // @@protoc_insertion_point(field_mutable_list:LayerDataBlockMsg.dataBlocks)
  return &datablocks_;
}
inline const ::DataBlockMsg& LayerDataBlockMsg::datablocks(int index) const {
  // @@protoc_insertion_point(field_get:LayerDataBlockMsg.dataBlocks)
  return datablocks_.Get(index);
}
inline ::DataBlockMsg* LayerDataBlockMsg::add_datablocks() {
  // @@protoc_insertion_point(field_add:LayerDataBlockMsg.dataBlocks)
  return datablocks_.Add();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::DataBlockMsg >&
LayerDataBlockMsg::datablocks() const {
  // @@protoc_insertion_point(field_list:LayerDataBlockMsg.dataBlocks)
  return datablocks_;
}

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

// JobParamMsg

// string machineId = 1;
inline void JobParamMsg::clear_machineid() {
  machineid_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& JobParamMsg::machineid() const {
  // @@protoc_insertion_point(field_get:JobParamMsg.machineId)
  return machineid_.GetNoArena();
}
inline void JobParamMsg::set_machineid(const std::string& value) {
  
  machineid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:JobParamMsg.machineId)
}
inline void JobParamMsg::set_machineid(std::string&& value) {
  
  machineid_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:JobParamMsg.machineId)
}
inline void JobParamMsg::set_machineid(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  machineid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:JobParamMsg.machineId)
}
inline void JobParamMsg::set_machineid(const char* value, size_t size) {
  
  machineid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:JobParamMsg.machineId)
}
inline std::string* JobParamMsg::mutable_machineid() {
  
  // @@protoc_insertion_point(field_mutable:JobParamMsg.machineId)
  return machineid_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* JobParamMsg::release_machineid() {
  // @@protoc_insertion_point(field_release:JobParamMsg.machineId)
  
  return machineid_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void JobParamMsg::set_allocated_machineid(std::string* machineid) {
  if (machineid != nullptr) {
    
  } else {
    
  }
  machineid_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), machineid);
  // @@protoc_insertion_point(field_set_allocated:JobParamMsg.machineId)
}

// string jobName = 2;
inline void JobParamMsg::clear_jobname() {
  jobname_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& JobParamMsg::jobname() const {
  // @@protoc_insertion_point(field_get:JobParamMsg.jobName)
  return jobname_.GetNoArena();
}
inline void JobParamMsg::set_jobname(const std::string& value) {
  
  jobname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:JobParamMsg.jobName)
}
inline void JobParamMsg::set_jobname(std::string&& value) {
  
  jobname_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:JobParamMsg.jobName)
}
inline void JobParamMsg::set_jobname(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  jobname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:JobParamMsg.jobName)
}
inline void JobParamMsg::set_jobname(const char* value, size_t size) {
  
  jobname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:JobParamMsg.jobName)
}
inline std::string* JobParamMsg::mutable_jobname() {
  
  // @@protoc_insertion_point(field_mutable:JobParamMsg.jobName)
  return jobname_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* JobParamMsg::release_jobname() {
  // @@protoc_insertion_point(field_release:JobParamMsg.jobName)
  
  return jobname_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void JobParamMsg::set_allocated_jobname(std::string* jobname) {
  if (jobname != nullptr) {
    
  } else {
    
  }
  jobname_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), jobname);
  // @@protoc_insertion_point(field_set_allocated:JobParamMsg.jobName)
}

// string jobUid = 3;
inline void JobParamMsg::clear_jobuid() {
  jobuid_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& JobParamMsg::jobuid() const {
  // @@protoc_insertion_point(field_get:JobParamMsg.jobUid)
  return jobuid_.GetNoArena();
}
inline void JobParamMsg::set_jobuid(const std::string& value) {
  
  jobuid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:JobParamMsg.jobUid)
}
inline void JobParamMsg::set_jobuid(std::string&& value) {
  
  jobuid_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:JobParamMsg.jobUid)
}
inline void JobParamMsg::set_jobuid(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  jobuid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:JobParamMsg.jobUid)
}
inline void JobParamMsg::set_jobuid(const char* value, size_t size) {
  
  jobuid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:JobParamMsg.jobUid)
}
inline std::string* JobParamMsg::mutable_jobuid() {
  
  // @@protoc_insertion_point(field_mutable:JobParamMsg.jobUid)
  return jobuid_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* JobParamMsg::release_jobuid() {
  // @@protoc_insertion_point(field_release:JobParamMsg.jobUid)
  
  return jobuid_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void JobParamMsg::set_allocated_jobuid(std::string* jobuid) {
  if (jobuid != nullptr) {
    
  } else {
    
  }
  jobuid_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), jobuid);
  // @@protoc_insertion_point(field_set_allocated:JobParamMsg.jobUid)
}

// uint32 layerCount = 4;
inline void JobParamMsg::clear_layercount() {
  layercount_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 JobParamMsg::layercount() const {
  // @@protoc_insertion_point(field_get:JobParamMsg.layerCount)
  return layercount_;
}
inline void JobParamMsg::set_layercount(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  layercount_ = value;
  // @@protoc_insertion_point(field_set:JobParamMsg.layerCount)
}

// float thickness = 5;
inline void JobParamMsg::clear_thickness() {
  thickness_ = 0;
}
inline float JobParamMsg::thickness() const {
  // @@protoc_insertion_point(field_get:JobParamMsg.thickness)
  return thickness_;
}
inline void JobParamMsg::set_thickness(float value) {
  
  thickness_ = value;
  // @@protoc_insertion_point(field_set:JobParamMsg.thickness)
}

// repeated .PartMsg parts = 6;
inline int JobParamMsg::parts_size() const {
  return parts_.size();
}
inline void JobParamMsg::clear_parts() {
  parts_.Clear();
}
inline ::PartMsg* JobParamMsg::mutable_parts(int index) {
  // @@protoc_insertion_point(field_mutable:JobParamMsg.parts)
  return parts_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PartMsg >*
JobParamMsg::mutable_parts() {
  // @@protoc_insertion_point(field_mutable_list:JobParamMsg.parts)
  return &parts_;
}
inline const ::PartMsg& JobParamMsg::parts(int index) const {
  // @@protoc_insertion_point(field_get:JobParamMsg.parts)
  return parts_.Get(index);
}
inline ::PartMsg* JobParamMsg::add_parts() {
  // @@protoc_insertion_point(field_add:JobParamMsg.parts)
  return parts_.Add();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PartMsg >&
JobParamMsg::parts() const {
  // @@protoc_insertion_point(field_list:JobParamMsg.parts)
  return parts_;
}

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

// LayerDataReqMsg

// string machineId = 1;
inline void LayerDataReqMsg::clear_machineid() {
  machineid_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& LayerDataReqMsg::machineid() const {
  // @@protoc_insertion_point(field_get:LayerDataReqMsg.machineId)
  return machineid_.GetNoArena();
}
inline void LayerDataReqMsg::set_machineid(const std::string& value) {
  
  machineid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:LayerDataReqMsg.machineId)
}
inline void LayerDataReqMsg::set_machineid(std::string&& value) {
  
  machineid_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:LayerDataReqMsg.machineId)
}
inline void LayerDataReqMsg::set_machineid(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  machineid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:LayerDataReqMsg.machineId)
}
inline void LayerDataReqMsg::set_machineid(const char* value, size_t size) {
  
  machineid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:LayerDataReqMsg.machineId)
}
inline std::string* LayerDataReqMsg::mutable_machineid() {
  
  // @@protoc_insertion_point(field_mutable:LayerDataReqMsg.machineId)
  return machineid_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* LayerDataReqMsg::release_machineid() {
  // @@protoc_insertion_point(field_release:LayerDataReqMsg.machineId)
  
  return machineid_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void LayerDataReqMsg::set_allocated_machineid(std::string* machineid) {
  if (machineid != nullptr) {
    
  } else {
    
  }
  machineid_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), machineid);
  // @@protoc_insertion_point(field_set_allocated:LayerDataReqMsg.machineId)
}

// uint32 layerIndex = 2;
inline void LayerDataReqMsg::clear_layerindex() {
  layerindex_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 LayerDataReqMsg::layerindex() const {
  // @@protoc_insertion_point(field_get:LayerDataReqMsg.layerIndex)
  return layerindex_;
}
inline void LayerDataReqMsg::set_layerindex(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  layerindex_ = value;
  // @@protoc_insertion_point(field_set:LayerDataReqMsg.layerIndex)
}

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

// ResponseState

// repeated .StateMsg stateMsg = 1;
inline int ResponseState::statemsg_size() const {
  return statemsg_.size();
}
inline void ResponseState::clear_statemsg() {
  statemsg_.Clear();
}
inline ::StateMsg* ResponseState::mutable_statemsg(int index) {
  // @@protoc_insertion_point(field_mutable:ResponseState.stateMsg)
  return statemsg_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::StateMsg >*
ResponseState::mutable_statemsg() {
  // @@protoc_insertion_point(field_mutable_list:ResponseState.stateMsg)
  return &statemsg_;
}
inline const ::StateMsg& ResponseState::statemsg(int index) const {
  // @@protoc_insertion_point(field_get:ResponseState.stateMsg)
  return statemsg_.Get(index);
}
inline ::StateMsg* ResponseState::add_statemsg() {
  // @@protoc_insertion_point(field_add:ResponseState.stateMsg)
  return statemsg_.Add();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::StateMsg >&
ResponseState::statemsg() const {
  // @@protoc_insertion_point(field_list:ResponseState.stateMsg)
  return statemsg_;
}

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

// CameraDataMsg

// string machineId = 1;
inline void CameraDataMsg::clear_machineid() {
  machineid_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& CameraDataMsg::machineid() const {
  // @@protoc_insertion_point(field_get:CameraDataMsg.machineId)
  return machineid_.GetNoArena();
}
inline void CameraDataMsg::set_machineid(const std::string& value) {
  
  machineid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:CameraDataMsg.machineId)
}
inline void CameraDataMsg::set_machineid(std::string&& value) {
  
  machineid_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:CameraDataMsg.machineId)
}
inline void CameraDataMsg::set_machineid(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  machineid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:CameraDataMsg.machineId)
}
inline void CameraDataMsg::set_machineid(const char* value, size_t size) {
  
  machineid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:CameraDataMsg.machineId)
}
inline std::string* CameraDataMsg::mutable_machineid() {
  
  // @@protoc_insertion_point(field_mutable:CameraDataMsg.machineId)
  return machineid_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* CameraDataMsg::release_machineid() {
  // @@protoc_insertion_point(field_release:CameraDataMsg.machineId)
  
  return machineid_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void CameraDataMsg::set_allocated_machineid(std::string* machineid) {
  if (machineid != nullptr) {
    
  } else {
    
  }
  machineid_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), machineid);
  // @@protoc_insertion_point(field_set_allocated:CameraDataMsg.machineId)
}

// uint32 width = 2;
inline void CameraDataMsg::clear_width() {
  width_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 CameraDataMsg::width() const {
  // @@protoc_insertion_point(field_get:CameraDataMsg.width)
  return width_;
}
inline void CameraDataMsg::set_width(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  width_ = value;
  // @@protoc_insertion_point(field_set:CameraDataMsg.width)
}

// uint32 height = 3;
inline void CameraDataMsg::clear_height() {
  height_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 CameraDataMsg::height() const {
  // @@protoc_insertion_point(field_get:CameraDataMsg.height)
  return height_;
}
inline void CameraDataMsg::set_height(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  height_ = value;
  // @@protoc_insertion_point(field_set:CameraDataMsg.height)
}

// bytes datas = 4;
inline void CameraDataMsg::clear_datas() {
  datas_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& CameraDataMsg::datas() const {
  // @@protoc_insertion_point(field_get:CameraDataMsg.datas)
  return datas_.GetNoArena();
}
inline void CameraDataMsg::set_datas(const std::string& value) {
  
  datas_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:CameraDataMsg.datas)
}
inline void CameraDataMsg::set_datas(std::string&& value) {
  
  datas_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:CameraDataMsg.datas)
}
inline void CameraDataMsg::set_datas(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  datas_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:CameraDataMsg.datas)
}
inline void CameraDataMsg::set_datas(const void* value, size_t size) {
  
  datas_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:CameraDataMsg.datas)
}
inline std::string* CameraDataMsg::mutable_datas() {
  
  // @@protoc_insertion_point(field_mutable:CameraDataMsg.datas)
  return datas_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* CameraDataMsg::release_datas() {
  // @@protoc_insertion_point(field_release:CameraDataMsg.datas)
  
  return datas_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void CameraDataMsg::set_allocated_datas(std::string* datas) {
  if (datas != nullptr) {
    
  } else {
    
  }
  datas_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), datas);
  // @@protoc_insertion_point(field_set_allocated:CameraDataMsg.datas)
}

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

// AlarmMsg

// string time = 1;
inline void AlarmMsg::clear_time() {
  time_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& AlarmMsg::time() const {
  // @@protoc_insertion_point(field_get:AlarmMsg.time)
  return time_.GetNoArena();
}
inline void AlarmMsg::set_time(const std::string& value) {
  
  time_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:AlarmMsg.time)
}
inline void AlarmMsg::set_time(std::string&& value) {
  
  time_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:AlarmMsg.time)
}
inline void AlarmMsg::set_time(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  time_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:AlarmMsg.time)
}
inline void AlarmMsg::set_time(const char* value, size_t size) {
  
  time_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:AlarmMsg.time)
}
inline std::string* AlarmMsg::mutable_time() {
  
  // @@protoc_insertion_point(field_mutable:AlarmMsg.time)
  return time_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* AlarmMsg::release_time() {
  // @@protoc_insertion_point(field_release:AlarmMsg.time)
  
  return time_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void AlarmMsg::set_allocated_time(std::string* time) {
  if (time != nullptr) {
    
  } else {
    
  }
  time_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), time);
  // @@protoc_insertion_point(field_set_allocated:AlarmMsg.time)
}

// string task = 2;
inline void AlarmMsg::clear_task() {
  task_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& AlarmMsg::task() const {
  // @@protoc_insertion_point(field_get:AlarmMsg.task)
  return task_.GetNoArena();
}
inline void AlarmMsg::set_task(const std::string& value) {
  
  task_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:AlarmMsg.task)
}
inline void AlarmMsg::set_task(std::string&& value) {
  
  task_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:AlarmMsg.task)
}
inline void AlarmMsg::set_task(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  task_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:AlarmMsg.task)
}
inline void AlarmMsg::set_task(const char* value, size_t size) {
  
  task_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:AlarmMsg.task)
}
inline std::string* AlarmMsg::mutable_task() {
  
  // @@protoc_insertion_point(field_mutable:AlarmMsg.task)
  return task_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* AlarmMsg::release_task() {
  // @@protoc_insertion_point(field_release:AlarmMsg.task)
  
  return task_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void AlarmMsg::set_allocated_task(std::string* task) {
  if (task != nullptr) {
    
  } else {
    
  }
  task_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), task);
  // @@protoc_insertion_point(field_set_allocated:AlarmMsg.task)
}

// string type = 3;
inline void AlarmMsg::clear_type() {
  type_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& AlarmMsg::type() const {
  // @@protoc_insertion_point(field_get:AlarmMsg.type)
  return type_.GetNoArena();
}
inline void AlarmMsg::set_type(const std::string& value) {
  
  type_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:AlarmMsg.type)
}
inline void AlarmMsg::set_type(std::string&& value) {
  
  type_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:AlarmMsg.type)
}
inline void AlarmMsg::set_type(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  type_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:AlarmMsg.type)
}
inline void AlarmMsg::set_type(const char* value, size_t size) {
  
  type_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:AlarmMsg.type)
}
inline std::string* AlarmMsg::mutable_type() {
  
  // @@protoc_insertion_point(field_mutable:AlarmMsg.type)
  return type_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* AlarmMsg::release_type() {
  // @@protoc_insertion_point(field_release:AlarmMsg.type)
  
  return type_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void AlarmMsg::set_allocated_type(std::string* type) {
  if (type != nullptr) {
    
  } else {
    
  }
  type_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), type);
  // @@protoc_insertion_point(field_set_allocated:AlarmMsg.type)
}

// string detail = 4;
inline void AlarmMsg::clear_detail() {
  detail_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& AlarmMsg::detail() const {
  // @@protoc_insertion_point(field_get:AlarmMsg.detail)
  return detail_.GetNoArena();
}
inline void AlarmMsg::set_detail(const std::string& value) {
  
  detail_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:AlarmMsg.detail)
}
inline void AlarmMsg::set_detail(std::string&& value) {
  
  detail_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:AlarmMsg.detail)
}
inline void AlarmMsg::set_detail(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  detail_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:AlarmMsg.detail)
}
inline void AlarmMsg::set_detail(const char* value, size_t size) {
  
  detail_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:AlarmMsg.detail)
}
inline std::string* AlarmMsg::mutable_detail() {
  
  // @@protoc_insertion_point(field_mutable:AlarmMsg.detail)
  return detail_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* AlarmMsg::release_detail() {
  // @@protoc_insertion_point(field_release:AlarmMsg.detail)
  
  return detail_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void AlarmMsg::set_allocated_detail(std::string* detail) {
  if (detail != nullptr) {
    
  } else {
    
  }
  detail_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), detail);
  // @@protoc_insertion_point(field_set_allocated:AlarmMsg.detail)
}

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

// AlarmsMsg

// repeated .AlarmMsg alarms = 1;
inline int AlarmsMsg::alarms_size() const {
  return alarms_.size();
}
inline void AlarmsMsg::clear_alarms() {
  alarms_.Clear();
}
inline ::AlarmMsg* AlarmsMsg::mutable_alarms(int index) {
  // @@protoc_insertion_point(field_mutable:AlarmsMsg.alarms)
  return alarms_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::AlarmMsg >*
AlarmsMsg::mutable_alarms() {
  // @@protoc_insertion_point(field_mutable_list:AlarmsMsg.alarms)
  return &alarms_;
}
inline const ::AlarmMsg& AlarmsMsg::alarms(int index) const {
  // @@protoc_insertion_point(field_get:AlarmsMsg.alarms)
  return alarms_.Get(index);
}
inline ::AlarmMsg* AlarmsMsg::add_alarms() {
  // @@protoc_insertion_point(field_add:AlarmsMsg.alarms)
  return alarms_.Add();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::AlarmMsg >&
AlarmsMsg::alarms() const {
  // @@protoc_insertion_point(field_list:AlarmsMsg.alarms)
  return alarms_;
}

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

// TaskMsg

// int64 id = 1;
inline void TaskMsg::clear_id() {
  id_ = PROTOBUF_LONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::int64 TaskMsg::id() const {
  // @@protoc_insertion_point(field_get:TaskMsg.id)
  return id_;
}
inline void TaskMsg::set_id(::PROTOBUF_NAMESPACE_ID::int64 value) {
  
  id_ = value;
  // @@protoc_insertion_point(field_set:TaskMsg.id)
}

// string name = 2;
inline void TaskMsg::clear_name() {
  name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& TaskMsg::name() const {
  // @@protoc_insertion_point(field_get:TaskMsg.name)
  return name_.GetNoArena();
}
inline void TaskMsg::set_name(const std::string& value) {
  
  name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:TaskMsg.name)
}
inline void TaskMsg::set_name(std::string&& value) {
  
  name_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:TaskMsg.name)
}
inline void TaskMsg::set_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:TaskMsg.name)
}
inline void TaskMsg::set_name(const char* value, size_t size) {
  
  name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:TaskMsg.name)
}
inline std::string* TaskMsg::mutable_name() {
  
  // @@protoc_insertion_point(field_mutable:TaskMsg.name)
  return name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* TaskMsg::release_name() {
  // @@protoc_insertion_point(field_release:TaskMsg.name)
  
  return name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void TaskMsg::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    
  } else {
    
  }
  name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name);
  // @@protoc_insertion_point(field_set_allocated:TaskMsg.name)
}

// string beginTime = 3;
inline void TaskMsg::clear_begintime() {
  begintime_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& TaskMsg::begintime() const {
  // @@protoc_insertion_point(field_get:TaskMsg.beginTime)
  return begintime_.GetNoArena();
}
inline void TaskMsg::set_begintime(const std::string& value) {
  
  begintime_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:TaskMsg.beginTime)
}
inline void TaskMsg::set_begintime(std::string&& value) {
  
  begintime_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:TaskMsg.beginTime)
}
inline void TaskMsg::set_begintime(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  begintime_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:TaskMsg.beginTime)
}
inline void TaskMsg::set_begintime(const char* value, size_t size) {
  
  begintime_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:TaskMsg.beginTime)
}
inline std::string* TaskMsg::mutable_begintime() {
  
  // @@protoc_insertion_point(field_mutable:TaskMsg.beginTime)
  return begintime_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* TaskMsg::release_begintime() {
  // @@protoc_insertion_point(field_release:TaskMsg.beginTime)
  
  return begintime_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void TaskMsg::set_allocated_begintime(std::string* begintime) {
  if (begintime != nullptr) {
    
  } else {
    
  }
  begintime_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), begintime);
  // @@protoc_insertion_point(field_set_allocated:TaskMsg.beginTime)
}

// string endTime = 4;
inline void TaskMsg::clear_endtime() {
  endtime_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& TaskMsg::endtime() const {
  // @@protoc_insertion_point(field_get:TaskMsg.endTime)
  return endtime_.GetNoArena();
}
inline void TaskMsg::set_endtime(const std::string& value) {
  
  endtime_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:TaskMsg.endTime)
}
inline void TaskMsg::set_endtime(std::string&& value) {
  
  endtime_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:TaskMsg.endTime)
}
inline void TaskMsg::set_endtime(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  endtime_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:TaskMsg.endTime)
}
inline void TaskMsg::set_endtime(const char* value, size_t size) {
  
  endtime_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:TaskMsg.endTime)
}
inline std::string* TaskMsg::mutable_endtime() {
  
  // @@protoc_insertion_point(field_mutable:TaskMsg.endTime)
  return endtime_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* TaskMsg::release_endtime() {
  // @@protoc_insertion_point(field_release:TaskMsg.endTime)
  
  return endtime_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void TaskMsg::set_allocated_endtime(std::string* endtime) {
  if (endtime != nullptr) {
    
  } else {
    
  }
  endtime_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), endtime);
  // @@protoc_insertion_point(field_set_allocated:TaskMsg.endTime)
}

// int64 deoxygenMinute = 5;
inline void TaskMsg::clear_deoxygenminute() {
  deoxygenminute_ = PROTOBUF_LONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::int64 TaskMsg::deoxygenminute() const {
  // @@protoc_insertion_point(field_get:TaskMsg.deoxygenMinute)
  return deoxygenminute_;
}
inline void TaskMsg::set_deoxygenminute(::PROTOBUF_NAMESPACE_ID::int64 value) {
  
  deoxygenminute_ = value;
  // @@protoc_insertion_point(field_set:TaskMsg.deoxygenMinute)
}

// int64 totalUseTime = 6;
inline void TaskMsg::clear_totalusetime() {
  totalusetime_ = PROTOBUF_LONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::int64 TaskMsg::totalusetime() const {
  // @@protoc_insertion_point(field_get:TaskMsg.totalUseTime)
  return totalusetime_;
}
inline void TaskMsg::set_totalusetime(::PROTOBUF_NAMESPACE_ID::int64 value) {
  
  totalusetime_ = value;
  // @@protoc_insertion_point(field_set:TaskMsg.totalUseTime)
}

// float logMoldPosition = 7;
inline void TaskMsg::clear_logmoldposition() {
  logmoldposition_ = 0;
}
inline float TaskMsg::logmoldposition() const {
  // @@protoc_insertion_point(field_get:TaskMsg.logMoldPosition)
  return logmoldposition_;
}
inline void TaskMsg::set_logmoldposition(float value) {
  
  logmoldposition_ = value;
  // @@protoc_insertion_point(field_set:TaskMsg.logMoldPosition)
}

// uint32 finishLayer = 8;
inline void TaskMsg::clear_finishlayer() {
  finishlayer_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 TaskMsg::finishlayer() const {
  // @@protoc_insertion_point(field_get:TaskMsg.finishLayer)
  return finishlayer_;
}
inline void TaskMsg::set_finishlayer(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  finishlayer_ = value;
  // @@protoc_insertion_point(field_set:TaskMsg.finishLayer)
}

// bool isFinish = 9;
inline void TaskMsg::clear_isfinish() {
  isfinish_ = false;
}
inline bool TaskMsg::isfinish() const {
  // @@protoc_insertion_point(field_get:TaskMsg.isFinish)
  return isfinish_;
}
inline void TaskMsg::set_isfinish(bool value) {
  
  isfinish_ = value;
  // @@protoc_insertion_point(field_set:TaskMsg.isFinish)
}

// bool isContinuePrint = 10;
inline void TaskMsg::clear_iscontinueprint() {
  iscontinueprint_ = false;
}
inline bool TaskMsg::iscontinueprint() const {
  // @@protoc_insertion_point(field_get:TaskMsg.isContinuePrint)
  return iscontinueprint_;
}
inline void TaskMsg::set_iscontinueprint(bool value) {
  
  iscontinueprint_ = value;
  // @@protoc_insertion_point(field_set:TaskMsg.isContinuePrint)
}

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

// TasksMsg

// repeated .TaskMsg tasks = 1;
inline int TasksMsg::tasks_size() const {
  return tasks_.size();
}
inline void TasksMsg::clear_tasks() {
  tasks_.Clear();
}
inline ::TaskMsg* TasksMsg::mutable_tasks(int index) {
  // @@protoc_insertion_point(field_mutable:TasksMsg.tasks)
  return tasks_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::TaskMsg >*
TasksMsg::mutable_tasks() {
  // @@protoc_insertion_point(field_mutable_list:TasksMsg.tasks)
  return &tasks_;
}
inline const ::TaskMsg& TasksMsg::tasks(int index) const {
  // @@protoc_insertion_point(field_get:TasksMsg.tasks)
  return tasks_.Get(index);
}
inline ::TaskMsg* TasksMsg::add_tasks() {
  // @@protoc_insertion_point(field_add:TasksMsg.tasks)
  return tasks_.Add();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::TaskMsg >&
TasksMsg::tasks() const {
  // @@protoc_insertion_point(field_list:TasksMsg.tasks)
  return tasks_;
}

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

// LayerStateMsg

// string layerDateTime = 1;
inline void LayerStateMsg::clear_layerdatetime() {
  layerdatetime_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& LayerStateMsg::layerdatetime() const {
  // @@protoc_insertion_point(field_get:LayerStateMsg.layerDateTime)
  return layerdatetime_.GetNoArena();
}
inline void LayerStateMsg::set_layerdatetime(const std::string& value) {
  
  layerdatetime_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:LayerStateMsg.layerDateTime)
}
inline void LayerStateMsg::set_layerdatetime(std::string&& value) {
  
  layerdatetime_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:LayerStateMsg.layerDateTime)
}
inline void LayerStateMsg::set_layerdatetime(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  layerdatetime_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:LayerStateMsg.layerDateTime)
}
inline void LayerStateMsg::set_layerdatetime(const char* value, size_t size) {
  
  layerdatetime_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:LayerStateMsg.layerDateTime)
}
inline std::string* LayerStateMsg::mutable_layerdatetime() {
  
  // @@protoc_insertion_point(field_mutable:LayerStateMsg.layerDateTime)
  return layerdatetime_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* LayerStateMsg::release_layerdatetime() {
  // @@protoc_insertion_point(field_release:LayerStateMsg.layerDateTime)
  
  return layerdatetime_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void LayerStateMsg::set_allocated_layerdatetime(std::string* layerdatetime) {
  if (layerdatetime != nullptr) {
    
  } else {
    
  }
  layerdatetime_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), layerdatetime);
  // @@protoc_insertion_point(field_set_allocated:LayerStateMsg.layerDateTime)
}

// uint32 layerIndex = 2;
inline void LayerStateMsg::clear_layerindex() {
  layerindex_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 LayerStateMsg::layerindex() const {
  // @@protoc_insertion_point(field_get:LayerStateMsg.layerIndex)
  return layerindex_;
}
inline void LayerStateMsg::set_layerindex(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  layerindex_ = value;
  // @@protoc_insertion_point(field_set:LayerStateMsg.layerIndex)
}

// float logMoldPosition = 3;
inline void LayerStateMsg::clear_logmoldposition() {
  logmoldposition_ = 0;
}
inline float LayerStateMsg::logmoldposition() const {
  // @@protoc_insertion_point(field_get:LayerStateMsg.logMoldPosition)
  return logmoldposition_;
}
inline void LayerStateMsg::set_logmoldposition(float value) {
  
  logmoldposition_ = value;
  // @@protoc_insertion_point(field_set:LayerStateMsg.logMoldPosition)
}

// float logOxygen = 4;
inline void LayerStateMsg::clear_logoxygen() {
  logoxygen_ = 0;
}
inline float LayerStateMsg::logoxygen() const {
  // @@protoc_insertion_point(field_get:LayerStateMsg.logOxygen)
  return logoxygen_;
}
inline void LayerStateMsg::set_logoxygen(float value) {
  
  logoxygen_ = value;
  // @@protoc_insertion_point(field_set:LayerStateMsg.logOxygen)
}

// float logInnerTemp = 5;
inline void LayerStateMsg::clear_loginnertemp() {
  loginnertemp_ = 0;
}
inline float LayerStateMsg::loginnertemp() const {
  // @@protoc_insertion_point(field_get:LayerStateMsg.logInnerTemp)
  return loginnertemp_;
}
inline void LayerStateMsg::set_loginnertemp(float value) {
  
  loginnertemp_ = value;
  // @@protoc_insertion_point(field_set:LayerStateMsg.logInnerTemp)
}

// float logPlateTemp = 6;
inline void LayerStateMsg::clear_logplatetemp() {
  logplatetemp_ = 0;
}
inline float LayerStateMsg::logplatetemp() const {
  // @@protoc_insertion_point(field_get:LayerStateMsg.logPlateTemp)
  return logplatetemp_;
}
inline void LayerStateMsg::set_logplatetemp(float value) {
  
  logplatetemp_ = value;
  // @@protoc_insertion_point(field_set:LayerStateMsg.logPlateTemp)
}

// float windSpeed = 7;
inline void LayerStateMsg::clear_windspeed() {
  windspeed_ = 0;
}
inline float LayerStateMsg::windspeed() const {
  // @@protoc_insertion_point(field_get:LayerStateMsg.windSpeed)
  return windspeed_;
}
inline void LayerStateMsg::set_windspeed(float value) {
  
  windspeed_ = value;
  // @@protoc_insertion_point(field_set:LayerStateMsg.windSpeed)
}

// float innerPressure = 8;
inline void LayerStateMsg::clear_innerpressure() {
  innerpressure_ = 0;
}
inline float LayerStateMsg::innerpressure() const {
  // @@protoc_insertion_point(field_get:LayerStateMsg.innerPressure)
  return innerpressure_;
}
inline void LayerStateMsg::set_innerpressure(float value) {
  
  innerpressure_ = value;
  // @@protoc_insertion_point(field_set:LayerStateMsg.innerPressure)
}

// float fanFreq = 9;
inline void LayerStateMsg::clear_fanfreq() {
  fanfreq_ = 0;
}
inline float LayerStateMsg::fanfreq() const {
  // @@protoc_insertion_point(field_get:LayerStateMsg.fanFreq)
  return fanfreq_;
}
inline void LayerStateMsg::set_fanfreq(float value) {
  
  fanfreq_ = value;
  // @@protoc_insertion_point(field_set:LayerStateMsg.fanFreq)
}

// float humidity = 10;
inline void LayerStateMsg::clear_humidity() {
  humidity_ = 0;
}
inline float LayerStateMsg::humidity() const {
  // @@protoc_insertion_point(field_get:LayerStateMsg.humidity)
  return humidity_;
}
inline void LayerStateMsg::set_humidity(float value) {
  
  humidity_ = value;
  // @@protoc_insertion_point(field_set:LayerStateMsg.humidity)
}

// float waterTemp = 11;
inline void LayerStateMsg::clear_watertemp() {
  watertemp_ = 0;
}
inline float LayerStateMsg::watertemp() const {
  // @@protoc_insertion_point(field_get:LayerStateMsg.waterTemp)
  return watertemp_;
}
inline void LayerStateMsg::set_watertemp(float value) {
  
  watertemp_ = value;
  // @@protoc_insertion_point(field_set:LayerStateMsg.waterTemp)
}

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

// LayerStatesMsg

// repeated .LayerStateMsg layerStates = 1;
inline int LayerStatesMsg::layerstates_size() const {
  return layerstates_.size();
}
inline void LayerStatesMsg::clear_layerstates() {
  layerstates_.Clear();
}
inline ::LayerStateMsg* LayerStatesMsg::mutable_layerstates(int index) {
  // @@protoc_insertion_point(field_mutable:LayerStatesMsg.layerStates)
  return layerstates_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::LayerStateMsg >*
LayerStatesMsg::mutable_layerstates() {
  // @@protoc_insertion_point(field_mutable_list:LayerStatesMsg.layerStates)
  return &layerstates_;
}
inline const ::LayerStateMsg& LayerStatesMsg::layerstates(int index) const {
  // @@protoc_insertion_point(field_get:LayerStatesMsg.layerStates)
  return layerstates_.Get(index);
}
inline ::LayerStateMsg* LayerStatesMsg::add_layerstates() {
  // @@protoc_insertion_point(field_add:LayerStatesMsg.layerStates)
  return layerstates_.Add();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::LayerStateMsg >&
LayerStatesMsg::layerstates() const {
  // @@protoc_insertion_point(field_list:LayerStatesMsg.layerStates)
  return layerstates_;
}

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

// LayerImageMsg

// int64 id = 1;
inline void LayerImageMsg::clear_id() {
  id_ = PROTOBUF_LONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::int64 LayerImageMsg::id() const {
  // @@protoc_insertion_point(field_get:LayerImageMsg.id)
  return id_;
}
inline void LayerImageMsg::set_id(::PROTOBUF_NAMESPACE_ID::int64 value) {
  
  id_ = value;
  // @@protoc_insertion_point(field_set:LayerImageMsg.id)
}

// uint32 layer = 2;
inline void LayerImageMsg::clear_layer() {
  layer_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 LayerImageMsg::layer() const {
  // @@protoc_insertion_point(field_get:LayerImageMsg.layer)
  return layer_;
}
inline void LayerImageMsg::set_layer(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  layer_ = value;
  // @@protoc_insertion_point(field_set:LayerImageMsg.layer)
}

// string type = 3;
inline void LayerImageMsg::clear_type() {
  type_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& LayerImageMsg::type() const {
  // @@protoc_insertion_point(field_get:LayerImageMsg.type)
  return type_.GetNoArena();
}
inline void LayerImageMsg::set_type(const std::string& value) {
  
  type_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:LayerImageMsg.type)
}
inline void LayerImageMsg::set_type(std::string&& value) {
  
  type_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:LayerImageMsg.type)
}
inline void LayerImageMsg::set_type(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  type_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:LayerImageMsg.type)
}
inline void LayerImageMsg::set_type(const char* value, size_t size) {
  
  type_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:LayerImageMsg.type)
}
inline std::string* LayerImageMsg::mutable_type() {
  
  // @@protoc_insertion_point(field_mutable:LayerImageMsg.type)
  return type_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* LayerImageMsg::release_type() {
  // @@protoc_insertion_point(field_release:LayerImageMsg.type)
  
  return type_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void LayerImageMsg::set_allocated_type(std::string* type) {
  if (type != nullptr) {
    
  } else {
    
  }
  type_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), type);
  // @@protoc_insertion_point(field_set_allocated:LayerImageMsg.type)
}

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

// LayerImagesMsg

// repeated .LayerImageMsg images = 1;
inline int LayerImagesMsg::images_size() const {
  return images_.size();
}
inline void LayerImagesMsg::clear_images() {
  images_.Clear();
}
inline ::LayerImageMsg* LayerImagesMsg::mutable_images(int index) {
  // @@protoc_insertion_point(field_mutable:LayerImagesMsg.images)
  return images_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::LayerImageMsg >*
LayerImagesMsg::mutable_images() {
  // @@protoc_insertion_point(field_mutable_list:LayerImagesMsg.images)
  return &images_;
}
inline const ::LayerImageMsg& LayerImagesMsg::images(int index) const {
  // @@protoc_insertion_point(field_get:LayerImagesMsg.images)
  return images_.Get(index);
}
inline ::LayerImageMsg* LayerImagesMsg::add_images() {
  // @@protoc_insertion_point(field_add:LayerImagesMsg.images)
  return images_.Add();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::LayerImageMsg >&
LayerImagesMsg::images() const {
  // @@protoc_insertion_point(field_list:LayerImagesMsg.images)
  return images_;
}

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

// LayerImageDataMsg

// uint64 imageSize = 1;
inline void LayerImageDataMsg::clear_imagesize() {
  imagesize_ = PROTOBUF_ULONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 LayerImageDataMsg::imagesize() const {
  // @@protoc_insertion_point(field_get:LayerImageDataMsg.imageSize)
  return imagesize_;
}
inline void LayerImageDataMsg::set_imagesize(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  
  imagesize_ = value;
  // @@protoc_insertion_point(field_set:LayerImageDataMsg.imageSize)
}

// bytes imageData = 2;
inline void LayerImageDataMsg::clear_imagedata() {
  imagedata_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& LayerImageDataMsg::imagedata() const {
  // @@protoc_insertion_point(field_get:LayerImageDataMsg.imageData)
  return imagedata_.GetNoArena();
}
inline void LayerImageDataMsg::set_imagedata(const std::string& value) {
  
  imagedata_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:LayerImageDataMsg.imageData)
}
inline void LayerImageDataMsg::set_imagedata(std::string&& value) {
  
  imagedata_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:LayerImageDataMsg.imageData)
}
inline void LayerImageDataMsg::set_imagedata(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  imagedata_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:LayerImageDataMsg.imageData)
}
inline void LayerImageDataMsg::set_imagedata(const void* value, size_t size) {
  
  imagedata_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:LayerImageDataMsg.imageData)
}
inline std::string* LayerImageDataMsg::mutable_imagedata() {
  
  // @@protoc_insertion_point(field_mutable:LayerImageDataMsg.imageData)
  return imagedata_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* LayerImageDataMsg::release_imagedata() {
  // @@protoc_insertion_point(field_release:LayerImageDataMsg.imageData)
  
  return imagedata_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void LayerImageDataMsg::set_allocated_imagedata(std::string* imagedata) {
  if (imagedata != nullptr) {
    
  } else {
    
  }
  imagedata_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), imagedata);
  // @@protoc_insertion_point(field_set_allocated:LayerImageDataMsg.imageData)
}

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

// LayerLoadCurveMsg

// int64 id = 1;
inline void LayerLoadCurveMsg::clear_id() {
  id_ = PROTOBUF_LONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::int64 LayerLoadCurveMsg::id() const {
  // @@protoc_insertion_point(field_get:LayerLoadCurveMsg.id)
  return id_;
}
inline void LayerLoadCurveMsg::set_id(::PROTOBUF_NAMESPACE_ID::int64 value) {
  
  id_ = value;
  // @@protoc_insertion_point(field_set:LayerLoadCurveMsg.id)
}

// uint32 layer = 2;
inline void LayerLoadCurveMsg::clear_layer() {
  layer_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 LayerLoadCurveMsg::layer() const {
  // @@protoc_insertion_point(field_get:LayerLoadCurveMsg.layer)
  return layer_;
}
inline void LayerLoadCurveMsg::set_layer(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  layer_ = value;
  // @@protoc_insertion_point(field_set:LayerLoadCurveMsg.layer)
}

// string coverType = 3;
inline void LayerLoadCurveMsg::clear_covertype() {
  covertype_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& LayerLoadCurveMsg::covertype() const {
  // @@protoc_insertion_point(field_get:LayerLoadCurveMsg.coverType)
  return covertype_.GetNoArena();
}
inline void LayerLoadCurveMsg::set_covertype(const std::string& value) {
  
  covertype_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:LayerLoadCurveMsg.coverType)
}
inline void LayerLoadCurveMsg::set_covertype(std::string&& value) {
  
  covertype_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:LayerLoadCurveMsg.coverType)
}
inline void LayerLoadCurveMsg::set_covertype(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  covertype_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:LayerLoadCurveMsg.coverType)
}
inline void LayerLoadCurveMsg::set_covertype(const char* value, size_t size) {
  
  covertype_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:LayerLoadCurveMsg.coverType)
}
inline std::string* LayerLoadCurveMsg::mutable_covertype() {
  
  // @@protoc_insertion_point(field_mutable:LayerLoadCurveMsg.coverType)
  return covertype_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* LayerLoadCurveMsg::release_covertype() {
  // @@protoc_insertion_point(field_release:LayerLoadCurveMsg.coverType)
  
  return covertype_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void LayerLoadCurveMsg::set_allocated_covertype(std::string* covertype) {
  if (covertype != nullptr) {
    
  } else {
    
  }
  covertype_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), covertype);
  // @@protoc_insertion_point(field_set_allocated:LayerLoadCurveMsg.coverType)
}

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

// LayerLoadCurvesMsg

// repeated .LayerLoadCurveMsg loadCurves = 1;
inline int LayerLoadCurvesMsg::loadcurves_size() const {
  return loadcurves_.size();
}
inline void LayerLoadCurvesMsg::clear_loadcurves() {
  loadcurves_.Clear();
}
inline ::LayerLoadCurveMsg* LayerLoadCurvesMsg::mutable_loadcurves(int index) {
  // @@protoc_insertion_point(field_mutable:LayerLoadCurvesMsg.loadCurves)
  return loadcurves_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::LayerLoadCurveMsg >*
LayerLoadCurvesMsg::mutable_loadcurves() {
  // @@protoc_insertion_point(field_mutable_list:LayerLoadCurvesMsg.loadCurves)
  return &loadcurves_;
}
inline const ::LayerLoadCurveMsg& LayerLoadCurvesMsg::loadcurves(int index) const {
  // @@protoc_insertion_point(field_get:LayerLoadCurvesMsg.loadCurves)
  return loadcurves_.Get(index);
}
inline ::LayerLoadCurveMsg* LayerLoadCurvesMsg::add_loadcurves() {
  // @@protoc_insertion_point(field_add:LayerLoadCurvesMsg.loadCurves)
  return loadcurves_.Add();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::LayerLoadCurveMsg >&
LayerLoadCurvesMsg::loadcurves() const {
  // @@protoc_insertion_point(field_list:LayerLoadCurvesMsg.loadCurves)
  return loadcurves_;
}

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

// LayerLoadCurveDataMsg

// repeated float mold = 1;
inline int LayerLoadCurveDataMsg::mold_size() const {
  return mold_.size();
}
inline void LayerLoadCurveDataMsg::clear_mold() {
  mold_.Clear();
}
inline float LayerLoadCurveDataMsg::mold(int index) const {
  // @@protoc_insertion_point(field_get:LayerLoadCurveDataMsg.mold)
  return mold_.Get(index);
}
inline void LayerLoadCurveDataMsg::set_mold(int index, float value) {
  mold_.Set(index, value);
  // @@protoc_insertion_point(field_set:LayerLoadCurveDataMsg.mold)
}
inline void LayerLoadCurveDataMsg::add_mold(float value) {
  mold_.Add(value);
  // @@protoc_insertion_point(field_add:LayerLoadCurveDataMsg.mold)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
LayerLoadCurveDataMsg::mold() const {
  // @@protoc_insertion_point(field_list:LayerLoadCurveDataMsg.mold)
  return mold_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
LayerLoadCurveDataMsg::mutable_mold() {
  // @@protoc_insertion_point(field_mutable_list:LayerLoadCurveDataMsg.mold)
  return &mold_;
}

// repeated float powder = 2;
inline int LayerLoadCurveDataMsg::powder_size() const {
  return powder_.size();
}
inline void LayerLoadCurveDataMsg::clear_powder() {
  powder_.Clear();
}
inline float LayerLoadCurveDataMsg::powder(int index) const {
  // @@protoc_insertion_point(field_get:LayerLoadCurveDataMsg.powder)
  return powder_.Get(index);
}
inline void LayerLoadCurveDataMsg::set_powder(int index, float value) {
  powder_.Set(index, value);
  // @@protoc_insertion_point(field_set:LayerLoadCurveDataMsg.powder)
}
inline void LayerLoadCurveDataMsg::add_powder(float value) {
  powder_.Add(value);
  // @@protoc_insertion_point(field_add:LayerLoadCurveDataMsg.powder)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
LayerLoadCurveDataMsg::powder() const {
  // @@protoc_insertion_point(field_list:LayerLoadCurveDataMsg.powder)
  return powder_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
LayerLoadCurveDataMsg::mutable_powder() {
  // @@protoc_insertion_point(field_mutable_list:LayerLoadCurveDataMsg.powder)
  return &powder_;
}

// repeated float arm = 3;
inline int LayerLoadCurveDataMsg::arm_size() const {
  return arm_.size();
}
inline void LayerLoadCurveDataMsg::clear_arm() {
  arm_.Clear();
}
inline float LayerLoadCurveDataMsg::arm(int index) const {
  // @@protoc_insertion_point(field_get:LayerLoadCurveDataMsg.arm)
  return arm_.Get(index);
}
inline void LayerLoadCurveDataMsg::set_arm(int index, float value) {
  arm_.Set(index, value);
  // @@protoc_insertion_point(field_set:LayerLoadCurveDataMsg.arm)
}
inline void LayerLoadCurveDataMsg::add_arm(float value) {
  arm_.Add(value);
  // @@protoc_insertion_point(field_add:LayerLoadCurveDataMsg.arm)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
LayerLoadCurveDataMsg::arm() const {
  // @@protoc_insertion_point(field_list:LayerLoadCurveDataMsg.arm)
  return arm_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
LayerLoadCurveDataMsg::mutable_arm() {
  // @@protoc_insertion_point(field_mutable_list:LayerLoadCurveDataMsg.arm)
  return &arm_;
}

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

// LogReqMsg

// .LogReqMsg.LogType type = 1;
inline void LogReqMsg::clear_type() {
  type_ = 0;
}
inline ::LogReqMsg_LogType LogReqMsg::type() const {
  // @@protoc_insertion_point(field_get:LogReqMsg.type)
  return static_cast< ::LogReqMsg_LogType >(type_);
}
inline void LogReqMsg::set_type(::LogReqMsg_LogType value) {
  
  type_ = value;
  // @@protoc_insertion_point(field_set:LogReqMsg.type)
}

// uint32 index = 2;
inline void LogReqMsg::clear_index() {
  index_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 LogReqMsg::index() const {
  // @@protoc_insertion_point(field_get:LogReqMsg.index)
  return index_;
}
inline void LogReqMsg::set_index(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  index_ = value;
  // @@protoc_insertion_point(field_set:LogReqMsg.index)
}

// uint32 pageSize = 3;
inline void LogReqMsg::clear_pagesize() {
  pagesize_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 LogReqMsg::pagesize() const {
  // @@protoc_insertion_point(field_get:LogReqMsg.pageSize)
  return pagesize_;
}
inline void LogReqMsg::set_pagesize(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  pagesize_ = value;
  // @@protoc_insertion_point(field_set:LogReqMsg.pageSize)
}

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

// LogRespMsg

// uint32 index = 1;
inline void LogRespMsg::clear_index() {
  index_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 LogRespMsg::index() const {
  // @@protoc_insertion_point(field_get:LogRespMsg.index)
  return index_;
}
inline void LogRespMsg::set_index(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  index_ = value;
  // @@protoc_insertion_point(field_set:LogRespMsg.index)
}

// uint32 pageSize = 2;
inline void LogRespMsg::clear_pagesize() {
  pagesize_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 LogRespMsg::pagesize() const {
  // @@protoc_insertion_point(field_get:LogRespMsg.pageSize)
  return pagesize_;
}
inline void LogRespMsg::set_pagesize(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  pagesize_ = value;
  // @@protoc_insertion_point(field_set:LogRespMsg.pageSize)
}

// uint32 total = 3;
inline void LogRespMsg::clear_total() {
  total_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 LogRespMsg::total() const {
  // @@protoc_insertion_point(field_get:LogRespMsg.total)
  return total_;
}
inline void LogRespMsg::set_total(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  total_ = value;
  // @@protoc_insertion_point(field_set:LogRespMsg.total)
}

// .AlarmsMsg alarms = 4;
inline bool LogRespMsg::has_alarms() const {
  return logresp_case() == kAlarms;
}
inline void LogRespMsg::set_has_alarms() {
  _oneof_case_[0] = kAlarms;
}
inline void LogRespMsg::clear_alarms() {
  if (has_alarms()) {
    delete logresp_.alarms_;
    clear_has_logresp();
  }
}
inline ::AlarmsMsg* LogRespMsg::release_alarms() {
  // @@protoc_insertion_point(field_release:LogRespMsg.alarms)
  if (has_alarms()) {
    clear_has_logresp();
      ::AlarmsMsg* temp = logresp_.alarms_;
    logresp_.alarms_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::AlarmsMsg& LogRespMsg::alarms() const {
  // @@protoc_insertion_point(field_get:LogRespMsg.alarms)
  return has_alarms()
      ? *logresp_.alarms_
      : *reinterpret_cast< ::AlarmsMsg*>(&::_AlarmsMsg_default_instance_);
}
inline ::AlarmsMsg* LogRespMsg::mutable_alarms() {
  if (!has_alarms()) {
    clear_logresp();
    set_has_alarms();
    logresp_.alarms_ = CreateMaybeMessage< ::AlarmsMsg >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:LogRespMsg.alarms)
  return logresp_.alarms_;
}

// .TasksMsg tasks = 5;
inline bool LogRespMsg::has_tasks() const {
  return logresp_case() == kTasks;
}
inline void LogRespMsg::set_has_tasks() {
  _oneof_case_[0] = kTasks;
}
inline void LogRespMsg::clear_tasks() {
  if (has_tasks()) {
    delete logresp_.tasks_;
    clear_has_logresp();
  }
}
inline ::TasksMsg* LogRespMsg::release_tasks() {
  // @@protoc_insertion_point(field_release:LogRespMsg.tasks)
  if (has_tasks()) {
    clear_has_logresp();
      ::TasksMsg* temp = logresp_.tasks_;
    logresp_.tasks_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::TasksMsg& LogRespMsg::tasks() const {
  // @@protoc_insertion_point(field_get:LogRespMsg.tasks)
  return has_tasks()
      ? *logresp_.tasks_
      : *reinterpret_cast< ::TasksMsg*>(&::_TasksMsg_default_instance_);
}
inline ::TasksMsg* LogRespMsg::mutable_tasks() {
  if (!has_tasks()) {
    clear_logresp();
    set_has_tasks();
    logresp_.tasks_ = CreateMaybeMessage< ::TasksMsg >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:LogRespMsg.tasks)
  return logresp_.tasks_;
}

// .LayerStatesMsg states = 6;
inline bool LogRespMsg::has_states() const {
  return logresp_case() == kStates;
}
inline void LogRespMsg::set_has_states() {
  _oneof_case_[0] = kStates;
}
inline void LogRespMsg::clear_states() {
  if (has_states()) {
    delete logresp_.states_;
    clear_has_logresp();
  }
}
inline ::LayerStatesMsg* LogRespMsg::release_states() {
  // @@protoc_insertion_point(field_release:LogRespMsg.states)
  if (has_states()) {
    clear_has_logresp();
      ::LayerStatesMsg* temp = logresp_.states_;
    logresp_.states_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::LayerStatesMsg& LogRespMsg::states() const {
  // @@protoc_insertion_point(field_get:LogRespMsg.states)
  return has_states()
      ? *logresp_.states_
      : *reinterpret_cast< ::LayerStatesMsg*>(&::_LayerStatesMsg_default_instance_);
}
inline ::LayerStatesMsg* LogRespMsg::mutable_states() {
  if (!has_states()) {
    clear_logresp();
    set_has_states();
    logresp_.states_ = CreateMaybeMessage< ::LayerStatesMsg >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:LogRespMsg.states)
  return logresp_.states_;
}

// .LayerImagesMsg images = 7;
inline bool LogRespMsg::has_images() const {
  return logresp_case() == kImages;
}
inline void LogRespMsg::set_has_images() {
  _oneof_case_[0] = kImages;
}
inline void LogRespMsg::clear_images() {
  if (has_images()) {
    delete logresp_.images_;
    clear_has_logresp();
  }
}
inline ::LayerImagesMsg* LogRespMsg::release_images() {
  // @@protoc_insertion_point(field_release:LogRespMsg.images)
  if (has_images()) {
    clear_has_logresp();
      ::LayerImagesMsg* temp = logresp_.images_;
    logresp_.images_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::LayerImagesMsg& LogRespMsg::images() const {
  // @@protoc_insertion_point(field_get:LogRespMsg.images)
  return has_images()
      ? *logresp_.images_
      : *reinterpret_cast< ::LayerImagesMsg*>(&::_LayerImagesMsg_default_instance_);
}
inline ::LayerImagesMsg* LogRespMsg::mutable_images() {
  if (!has_images()) {
    clear_logresp();
    set_has_images();
    logresp_.images_ = CreateMaybeMessage< ::LayerImagesMsg >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:LogRespMsg.images)
  return logresp_.images_;
}

// .LayerImageDataMsg imageData = 8;
inline bool LogRespMsg::has_imagedata() const {
  return logresp_case() == kImageData;
}
inline void LogRespMsg::set_has_imagedata() {
  _oneof_case_[0] = kImageData;
}
inline void LogRespMsg::clear_imagedata() {
  if (has_imagedata()) {
    delete logresp_.imagedata_;
    clear_has_logresp();
  }
}
inline ::LayerImageDataMsg* LogRespMsg::release_imagedata() {
  // @@protoc_insertion_point(field_release:LogRespMsg.imageData)
  if (has_imagedata()) {
    clear_has_logresp();
      ::LayerImageDataMsg* temp = logresp_.imagedata_;
    logresp_.imagedata_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::LayerImageDataMsg& LogRespMsg::imagedata() const {
  // @@protoc_insertion_point(field_get:LogRespMsg.imageData)
  return has_imagedata()
      ? *logresp_.imagedata_
      : *reinterpret_cast< ::LayerImageDataMsg*>(&::_LayerImageDataMsg_default_instance_);
}
inline ::LayerImageDataMsg* LogRespMsg::mutable_imagedata() {
  if (!has_imagedata()) {
    clear_logresp();
    set_has_imagedata();
    logresp_.imagedata_ = CreateMaybeMessage< ::LayerImageDataMsg >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:LogRespMsg.imageData)
  return logresp_.imagedata_;
}

// .LayerLoadCurvesMsg loadCurves = 9;
inline bool LogRespMsg::has_loadcurves() const {
  return logresp_case() == kLoadCurves;
}
inline void LogRespMsg::set_has_loadcurves() {
  _oneof_case_[0] = kLoadCurves;
}
inline void LogRespMsg::clear_loadcurves() {
  if (has_loadcurves()) {
    delete logresp_.loadcurves_;
    clear_has_logresp();
  }
}
inline ::LayerLoadCurvesMsg* LogRespMsg::release_loadcurves() {
  // @@protoc_insertion_point(field_release:LogRespMsg.loadCurves)
  if (has_loadcurves()) {
    clear_has_logresp();
      ::LayerLoadCurvesMsg* temp = logresp_.loadcurves_;
    logresp_.loadcurves_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::LayerLoadCurvesMsg& LogRespMsg::loadcurves() const {
  // @@protoc_insertion_point(field_get:LogRespMsg.loadCurves)
  return has_loadcurves()
      ? *logresp_.loadcurves_
      : *reinterpret_cast< ::LayerLoadCurvesMsg*>(&::_LayerLoadCurvesMsg_default_instance_);
}
inline ::LayerLoadCurvesMsg* LogRespMsg::mutable_loadcurves() {
  if (!has_loadcurves()) {
    clear_logresp();
    set_has_loadcurves();
    logresp_.loadcurves_ = CreateMaybeMessage< ::LayerLoadCurvesMsg >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:LogRespMsg.loadCurves)
  return logresp_.loadcurves_;
}

// .LayerLoadCurveDataMsg loadCurveData = 10;
inline bool LogRespMsg::has_loadcurvedata() const {
  return logresp_case() == kLoadCurveData;
}
inline void LogRespMsg::set_has_loadcurvedata() {
  _oneof_case_[0] = kLoadCurveData;
}
inline void LogRespMsg::clear_loadcurvedata() {
  if (has_loadcurvedata()) {
    delete logresp_.loadcurvedata_;
    clear_has_logresp();
  }
}
inline ::LayerLoadCurveDataMsg* LogRespMsg::release_loadcurvedata() {
  // @@protoc_insertion_point(field_release:LogRespMsg.loadCurveData)
  if (has_loadcurvedata()) {
    clear_has_logresp();
      ::LayerLoadCurveDataMsg* temp = logresp_.loadcurvedata_;
    logresp_.loadcurvedata_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::LayerLoadCurveDataMsg& LogRespMsg::loadcurvedata() const {
  // @@protoc_insertion_point(field_get:LogRespMsg.loadCurveData)
  return has_loadcurvedata()
      ? *logresp_.loadcurvedata_
      : *reinterpret_cast< ::LayerLoadCurveDataMsg*>(&::_LayerLoadCurveDataMsg_default_instance_);
}
inline ::LayerLoadCurveDataMsg* LogRespMsg::mutable_loadcurvedata() {
  if (!has_loadcurvedata()) {
    clear_logresp();
    set_has_loadcurvedata();
    logresp_.loadcurvedata_ = CreateMaybeMessage< ::LayerLoadCurveDataMsg >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:LogRespMsg.loadCurveData)
  return logresp_.loadcurvedata_;
}

inline bool LogRespMsg::has_logresp() const {
  return logresp_case() != LOGRESP_NOT_SET;
}
inline void LogRespMsg::clear_has_logresp() {
  _oneof_case_[0] = LOGRESP_NOT_SET;
}
inline LogRespMsg::LogrespCase LogRespMsg::logresp_case() const {
  return LogRespMsg::LogrespCase(_oneof_case_[0]);
}
// -------------------------------------------------------------------

// LogFetchReqMsg

// .LogFetchReqMsg.LogType type = 1;
inline void LogFetchReqMsg::clear_type() {
  type_ = 0;
}
inline ::LogFetchReqMsg_LogType LogFetchReqMsg::type() const {
  // @@protoc_insertion_point(field_get:LogFetchReqMsg.type)
  return static_cast< ::LogFetchReqMsg_LogType >(type_);
}
inline void LogFetchReqMsg::set_type(::LogFetchReqMsg_LogType value) {
  
  type_ = value;
  // @@protoc_insertion_point(field_set:LogFetchReqMsg.type)
}

// int64 begin = 2;
inline void LogFetchReqMsg::clear_begin() {
  begin_ = PROTOBUF_LONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::int64 LogFetchReqMsg::begin() const {
  // @@protoc_insertion_point(field_get:LogFetchReqMsg.begin)
  return begin_;
}
inline void LogFetchReqMsg::set_begin(::PROTOBUF_NAMESPACE_ID::int64 value) {
  
  begin_ = value;
  // @@protoc_insertion_point(field_set:LogFetchReqMsg.begin)
}

// int64 end = 3;
inline void LogFetchReqMsg::clear_end() {
  end_ = PROTOBUF_LONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::int64 LogFetchReqMsg::end() const {
  // @@protoc_insertion_point(field_get:LogFetchReqMsg.end)
  return end_;
}
inline void LogFetchReqMsg::set_end(::PROTOBUF_NAMESPACE_ID::int64 value) {
  
  end_ = value;
  // @@protoc_insertion_point(field_set:LogFetchReqMsg.end)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


// @@protoc_insertion_point(namespace_scope)


PROTOBUF_NAMESPACE_OPEN

template <> struct is_proto_enum< ::StateMsg_PrintState> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::StateMsg_PrintState>() {
  return ::StateMsg_PrintState_descriptor();
}
template <> struct is_proto_enum< ::JobStateMsg_JobState> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::JobStateMsg_JobState>() {
  return ::JobStateMsg_JobState_descriptor();
}
template <> struct is_proto_enum< ::MachineMsg_MachineType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::MachineMsg_MachineType>() {
  return ::MachineMsg_MachineType_descriptor();
}
template <> struct is_proto_enum< ::MachineMsg_PurifierType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::MachineMsg_PurifierType>() {
  return ::MachineMsg_PurifierType_descriptor();
}
template <> struct is_proto_enum< ::ErrorMsg_ErrorType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::ErrorMsg_ErrorType>() {
  return ::ErrorMsg_ErrorType_descriptor();
}
template <> struct is_proto_enum< ::LogReqMsg_LogType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::LogReqMsg_LogType>() {
  return ::LogReqMsg_LogType_descriptor();
}
template <> struct is_proto_enum< ::LogFetchReqMsg_LogType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::LogFetchReqMsg_LogType>() {
  return ::LogFetchReqMsg_LogType_descriptor();
}

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

#include <google/protobuf/port_undef.inc>
#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_common_2eproto