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

#ifndef GOOGLE_PROTOBUF_INCLUDED_log_5fprocess_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_log_5fprocess_2eproto

#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3013000
#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 3013000 < 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_lite.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/generated_enum_reflection.h>
#include <google/protobuf/unknown_field_set.h>
#include "message_base.pb.h"
#include "parkspace_allocation_message.pb.h"
#include "measure_message.pb.h"
#include "dispatch_message.pb.h"
#include "central_control_message.pb.h"
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_log_5fprocess_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_log_5fprocess_2eproto {
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[6]
    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_log_5fprocess_2eproto;
namespace message {
class Dispatch_data;
class Dispatch_dataDefaultTypeInternal;
extern Dispatch_dataDefaultTypeInternal _Dispatch_data_default_instance_;
class Log_data;
class Log_dataDefaultTypeInternal;
extern Log_dataDefaultTypeInternal _Log_data_default_instance_;
class Manual_operation_data;
class Manual_operation_dataDefaultTypeInternal;
extern Manual_operation_dataDefaultTypeInternal _Manual_operation_data_default_instance_;
class Measure_data;
class Measure_dataDefaultTypeInternal;
extern Measure_dataDefaultTypeInternal _Measure_data_default_instance_;
class Parkspace_data;
class Parkspace_dataDefaultTypeInternal;
extern Parkspace_dataDefaultTypeInternal _Parkspace_data_default_instance_;
class Process_log;
class Process_logDefaultTypeInternal;
extern Process_logDefaultTypeInternal _Process_log_default_instance_;
}  // namespace message
PROTOBUF_NAMESPACE_OPEN
template<> ::message::Dispatch_data* Arena::CreateMaybeMessage<::message::Dispatch_data>(Arena*);
template<> ::message::Log_data* Arena::CreateMaybeMessage<::message::Log_data>(Arena*);
template<> ::message::Manual_operation_data* Arena::CreateMaybeMessage<::message::Manual_operation_data>(Arena*);
template<> ::message::Measure_data* Arena::CreateMaybeMessage<::message::Measure_data>(Arena*);
template<> ::message::Parkspace_data* Arena::CreateMaybeMessage<::message::Parkspace_data>(Arena*);
template<> ::message::Process_log* Arena::CreateMaybeMessage<::message::Process_log>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace message {

enum Log_data_Severity : int {
  Log_data_Severity_INFO = 0,
  Log_data_Severity_WARNING = 1,
  Log_data_Severity_ERROR = 2
};
bool Log_data_Severity_IsValid(int value);
constexpr Log_data_Severity Log_data_Severity_Severity_MIN = Log_data_Severity_INFO;
constexpr Log_data_Severity Log_data_Severity_Severity_MAX = Log_data_Severity_ERROR;
constexpr int Log_data_Severity_Severity_ARRAYSIZE = Log_data_Severity_Severity_MAX + 1;

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

class Parkspace_data PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:message.Parkspace_data) */ {
 public:
  inline Parkspace_data() : Parkspace_data(nullptr) {}
  virtual ~Parkspace_data();

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

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

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

  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 Parkspace_data& default_instance();

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

  friend void swap(Parkspace_data& a, Parkspace_data& b) {
    a.Swap(&b);
  }
  inline void Swap(Parkspace_data* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Parkspace_data* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

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

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

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) 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(Parkspace_data* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "message.Parkspace_data";
  }
  protected:
  explicit Parkspace_data(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

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

  public:

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

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

  enum : int {
    kDescriptionFieldNumber = 9,
    kAllocRequestFieldNumber = 1,
    kAllocResponseFieldNumber = 2,
    kSearchRequestFieldNumber = 3,
    kSearchResponseFieldNumber = 4,
    kReleaseRequestFieldNumber = 5,
    kReleaseResponseFieldNumber = 6,
    kConfirmRequestFieldNumber = 7,
    kConfirmResponseFieldNumber = 8,
  };
  // optional string description = 9;
  bool has_description() const;
  private:
  bool _internal_has_description() const;
  public:
  void clear_description();
  const std::string& description() const;
  void set_description(const std::string& value);
  void set_description(std::string&& value);
  void set_description(const char* value);
  void set_description(const char* value, size_t size);
  std::string* mutable_description();
  std::string* release_description();
  void set_allocated_description(std::string* description);
  private:
  const std::string& _internal_description() const;
  void _internal_set_description(const std::string& value);
  std::string* _internal_mutable_description();
  public:

  // optional .message.Parkspace_allocation_request_msg alloc_request = 1;
  bool has_alloc_request() const;
  private:
  bool _internal_has_alloc_request() const;
  public:
  void clear_alloc_request();
  const ::message::Parkspace_allocation_request_msg& alloc_request() const;
  ::message::Parkspace_allocation_request_msg* release_alloc_request();
  ::message::Parkspace_allocation_request_msg* mutable_alloc_request();
  void set_allocated_alloc_request(::message::Parkspace_allocation_request_msg* alloc_request);
  private:
  const ::message::Parkspace_allocation_request_msg& _internal_alloc_request() const;
  ::message::Parkspace_allocation_request_msg* _internal_mutable_alloc_request();
  public:
  void unsafe_arena_set_allocated_alloc_request(
      ::message::Parkspace_allocation_request_msg* alloc_request);
  ::message::Parkspace_allocation_request_msg* unsafe_arena_release_alloc_request();

  // optional .message.Parkspace_allocation_response_msg alloc_response = 2;
  bool has_alloc_response() const;
  private:
  bool _internal_has_alloc_response() const;
  public:
  void clear_alloc_response();
  const ::message::Parkspace_allocation_response_msg& alloc_response() const;
  ::message::Parkspace_allocation_response_msg* release_alloc_response();
  ::message::Parkspace_allocation_response_msg* mutable_alloc_response();
  void set_allocated_alloc_response(::message::Parkspace_allocation_response_msg* alloc_response);
  private:
  const ::message::Parkspace_allocation_response_msg& _internal_alloc_response() const;
  ::message::Parkspace_allocation_response_msg* _internal_mutable_alloc_response();
  public:
  void unsafe_arena_set_allocated_alloc_response(
      ::message::Parkspace_allocation_response_msg* alloc_response);
  ::message::Parkspace_allocation_response_msg* unsafe_arena_release_alloc_response();

  // optional .message.Parkspace_search_request_msg search_request = 3;
  bool has_search_request() const;
  private:
  bool _internal_has_search_request() const;
  public:
  void clear_search_request();
  const ::message::Parkspace_search_request_msg& search_request() const;
  ::message::Parkspace_search_request_msg* release_search_request();
  ::message::Parkspace_search_request_msg* mutable_search_request();
  void set_allocated_search_request(::message::Parkspace_search_request_msg* search_request);
  private:
  const ::message::Parkspace_search_request_msg& _internal_search_request() const;
  ::message::Parkspace_search_request_msg* _internal_mutable_search_request();
  public:
  void unsafe_arena_set_allocated_search_request(
      ::message::Parkspace_search_request_msg* search_request);
  ::message::Parkspace_search_request_msg* unsafe_arena_release_search_request();

  // optional .message.Parkspace_search_response_msg search_response = 4;
  bool has_search_response() const;
  private:
  bool _internal_has_search_response() const;
  public:
  void clear_search_response();
  const ::message::Parkspace_search_response_msg& search_response() const;
  ::message::Parkspace_search_response_msg* release_search_response();
  ::message::Parkspace_search_response_msg* mutable_search_response();
  void set_allocated_search_response(::message::Parkspace_search_response_msg* search_response);
  private:
  const ::message::Parkspace_search_response_msg& _internal_search_response() const;
  ::message::Parkspace_search_response_msg* _internal_mutable_search_response();
  public:
  void unsafe_arena_set_allocated_search_response(
      ::message::Parkspace_search_response_msg* search_response);
  ::message::Parkspace_search_response_msg* unsafe_arena_release_search_response();

  // optional .message.Parkspace_release_request_msg release_request = 5;
  bool has_release_request() const;
  private:
  bool _internal_has_release_request() const;
  public:
  void clear_release_request();
  const ::message::Parkspace_release_request_msg& release_request() const;
  ::message::Parkspace_release_request_msg* release_release_request();
  ::message::Parkspace_release_request_msg* mutable_release_request();
  void set_allocated_release_request(::message::Parkspace_release_request_msg* release_request);
  private:
  const ::message::Parkspace_release_request_msg& _internal_release_request() const;
  ::message::Parkspace_release_request_msg* _internal_mutable_release_request();
  public:
  void unsafe_arena_set_allocated_release_request(
      ::message::Parkspace_release_request_msg* release_request);
  ::message::Parkspace_release_request_msg* unsafe_arena_release_release_request();

  // optional .message.Parkspace_release_response_msg release_response = 6;
  bool has_release_response() const;
  private:
  bool _internal_has_release_response() const;
  public:
  void clear_release_response();
  const ::message::Parkspace_release_response_msg& release_response() const;
  ::message::Parkspace_release_response_msg* release_release_response();
  ::message::Parkspace_release_response_msg* mutable_release_response();
  void set_allocated_release_response(::message::Parkspace_release_response_msg* release_response);
  private:
  const ::message::Parkspace_release_response_msg& _internal_release_response() const;
  ::message::Parkspace_release_response_msg* _internal_mutable_release_response();
  public:
  void unsafe_arena_set_allocated_release_response(
      ::message::Parkspace_release_response_msg* release_response);
  ::message::Parkspace_release_response_msg* unsafe_arena_release_release_response();

  // optional .message.Parkspace_confirm_alloc_request_msg confirm_request = 7;
  bool has_confirm_request() const;
  private:
  bool _internal_has_confirm_request() const;
  public:
  void clear_confirm_request();
  const ::message::Parkspace_confirm_alloc_request_msg& confirm_request() const;
  ::message::Parkspace_confirm_alloc_request_msg* release_confirm_request();
  ::message::Parkspace_confirm_alloc_request_msg* mutable_confirm_request();
  void set_allocated_confirm_request(::message::Parkspace_confirm_alloc_request_msg* confirm_request);
  private:
  const ::message::Parkspace_confirm_alloc_request_msg& _internal_confirm_request() const;
  ::message::Parkspace_confirm_alloc_request_msg* _internal_mutable_confirm_request();
  public:
  void unsafe_arena_set_allocated_confirm_request(
      ::message::Parkspace_confirm_alloc_request_msg* confirm_request);
  ::message::Parkspace_confirm_alloc_request_msg* unsafe_arena_release_confirm_request();

  // optional .message.Parkspace_confirm_alloc_response_msg confirm_response = 8;
  bool has_confirm_response() const;
  private:
  bool _internal_has_confirm_response() const;
  public:
  void clear_confirm_response();
  const ::message::Parkspace_confirm_alloc_response_msg& confirm_response() const;
  ::message::Parkspace_confirm_alloc_response_msg* release_confirm_response();
  ::message::Parkspace_confirm_alloc_response_msg* mutable_confirm_response();
  void set_allocated_confirm_response(::message::Parkspace_confirm_alloc_response_msg* confirm_response);
  private:
  const ::message::Parkspace_confirm_alloc_response_msg& _internal_confirm_response() const;
  ::message::Parkspace_confirm_alloc_response_msg* _internal_mutable_confirm_response();
  public:
  void unsafe_arena_set_allocated_confirm_response(
      ::message::Parkspace_confirm_alloc_response_msg* confirm_response);
  ::message::Parkspace_confirm_alloc_response_msg* unsafe_arena_release_confirm_response();

  // @@protoc_insertion_point(class_scope:message.Parkspace_data)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr description_;
  ::message::Parkspace_allocation_request_msg* alloc_request_;
  ::message::Parkspace_allocation_response_msg* alloc_response_;
  ::message::Parkspace_search_request_msg* search_request_;
  ::message::Parkspace_search_response_msg* search_response_;
  ::message::Parkspace_release_request_msg* release_request_;
  ::message::Parkspace_release_response_msg* release_response_;
  ::message::Parkspace_confirm_alloc_request_msg* confirm_request_;
  ::message::Parkspace_confirm_alloc_response_msg* confirm_response_;
  friend struct ::TableStruct_log_5fprocess_2eproto;
};
// -------------------------------------------------------------------

class Measure_data PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:message.Measure_data) */ {
 public:
  inline Measure_data() : Measure_data(nullptr) {}
  virtual ~Measure_data();

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

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

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

  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 Measure_data& default_instance();

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

  friend void swap(Measure_data& a, Measure_data& b) {
    a.Swap(&b);
  }
  inline void Swap(Measure_data* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Measure_data* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

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

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

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) 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(Measure_data* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "message.Measure_data";
  }
  protected:
  explicit Measure_data(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

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

  public:

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

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

  enum : int {
    kDescriptionFieldNumber = 3,
    kRequestFieldNumber = 1,
    kResponseFieldNumber = 2,
  };
  // optional string description = 3;
  bool has_description() const;
  private:
  bool _internal_has_description() const;
  public:
  void clear_description();
  const std::string& description() const;
  void set_description(const std::string& value);
  void set_description(std::string&& value);
  void set_description(const char* value);
  void set_description(const char* value, size_t size);
  std::string* mutable_description();
  std::string* release_description();
  void set_allocated_description(std::string* description);
  private:
  const std::string& _internal_description() const;
  void _internal_set_description(const std::string& value);
  std::string* _internal_mutable_description();
  public:

  // optional .message.Measure_request_msg request = 1;
  bool has_request() const;
  private:
  bool _internal_has_request() const;
  public:
  void clear_request();
  const ::message::Measure_request_msg& request() const;
  ::message::Measure_request_msg* release_request();
  ::message::Measure_request_msg* mutable_request();
  void set_allocated_request(::message::Measure_request_msg* request);
  private:
  const ::message::Measure_request_msg& _internal_request() const;
  ::message::Measure_request_msg* _internal_mutable_request();
  public:
  void unsafe_arena_set_allocated_request(
      ::message::Measure_request_msg* request);
  ::message::Measure_request_msg* unsafe_arena_release_request();

  // optional .message.Measure_response_msg response = 2;
  bool has_response() const;
  private:
  bool _internal_has_response() const;
  public:
  void clear_response();
  const ::message::Measure_response_msg& response() const;
  ::message::Measure_response_msg* release_response();
  ::message::Measure_response_msg* mutable_response();
  void set_allocated_response(::message::Measure_response_msg* response);
  private:
  const ::message::Measure_response_msg& _internal_response() const;
  ::message::Measure_response_msg* _internal_mutable_response();
  public:
  void unsafe_arena_set_allocated_response(
      ::message::Measure_response_msg* response);
  ::message::Measure_response_msg* unsafe_arena_release_response();

  // @@protoc_insertion_point(class_scope:message.Measure_data)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr description_;
  ::message::Measure_request_msg* request_;
  ::message::Measure_response_msg* response_;
  friend struct ::TableStruct_log_5fprocess_2eproto;
};
// -------------------------------------------------------------------

class Dispatch_data PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:message.Dispatch_data) */ {
 public:
  inline Dispatch_data() : Dispatch_data(nullptr) {}
  virtual ~Dispatch_data();

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

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

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

  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 Dispatch_data& default_instance();

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

  friend void swap(Dispatch_data& a, Dispatch_data& b) {
    a.Swap(&b);
  }
  inline void Swap(Dispatch_data* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Dispatch_data* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

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

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

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) 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(Dispatch_data* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "message.Dispatch_data";
  }
  protected:
  explicit Dispatch_data(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

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

  public:

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

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

  enum : int {
    kDescriptionFieldNumber = 3,
    kRequestFieldNumber = 1,
    kResponseFieldNumber = 2,
  };
  // optional string description = 3;
  bool has_description() const;
  private:
  bool _internal_has_description() const;
  public:
  void clear_description();
  const std::string& description() const;
  void set_description(const std::string& value);
  void set_description(std::string&& value);
  void set_description(const char* value);
  void set_description(const char* value, size_t size);
  std::string* mutable_description();
  std::string* release_description();
  void set_allocated_description(std::string* description);
  private:
  const std::string& _internal_description() const;
  void _internal_set_description(const std::string& value);
  std::string* _internal_mutable_description();
  public:

  // optional .message.Dispatch_request_msg request = 1;
  bool has_request() const;
  private:
  bool _internal_has_request() const;
  public:
  void clear_request();
  const ::message::Dispatch_request_msg& request() const;
  ::message::Dispatch_request_msg* release_request();
  ::message::Dispatch_request_msg* mutable_request();
  void set_allocated_request(::message::Dispatch_request_msg* request);
  private:
  const ::message::Dispatch_request_msg& _internal_request() const;
  ::message::Dispatch_request_msg* _internal_mutable_request();
  public:
  void unsafe_arena_set_allocated_request(
      ::message::Dispatch_request_msg* request);
  ::message::Dispatch_request_msg* unsafe_arena_release_request();

  // optional .message.Dispatch_response_msg response = 2;
  bool has_response() const;
  private:
  bool _internal_has_response() const;
  public:
  void clear_response();
  const ::message::Dispatch_response_msg& response() const;
  ::message::Dispatch_response_msg* release_response();
  ::message::Dispatch_response_msg* mutable_response();
  void set_allocated_response(::message::Dispatch_response_msg* response);
  private:
  const ::message::Dispatch_response_msg& _internal_response() const;
  ::message::Dispatch_response_msg* _internal_mutable_response();
  public:
  void unsafe_arena_set_allocated_response(
      ::message::Dispatch_response_msg* response);
  ::message::Dispatch_response_msg* unsafe_arena_release_response();

  // @@protoc_insertion_point(class_scope:message.Dispatch_data)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr description_;
  ::message::Dispatch_request_msg* request_;
  ::message::Dispatch_response_msg* response_;
  friend struct ::TableStruct_log_5fprocess_2eproto;
};
// -------------------------------------------------------------------

class Manual_operation_data PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:message.Manual_operation_data) */ {
 public:
  inline Manual_operation_data() : Manual_operation_data(nullptr) {}
  virtual ~Manual_operation_data();

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

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

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

  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 Manual_operation_data& default_instance();

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

  friend void swap(Manual_operation_data& a, Manual_operation_data& b) {
    a.Swap(&b);
  }
  inline void Swap(Manual_operation_data* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Manual_operation_data* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

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

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

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) 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(Manual_operation_data* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "message.Manual_operation_data";
  }
  protected:
  explicit Manual_operation_data(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

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

  public:

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

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

  enum : int {
    kDescriptionFieldNumber = 2,
    kManualOperationFieldNumber = 1,
  };
  // optional string description = 2;
  bool has_description() const;
  private:
  bool _internal_has_description() const;
  public:
  void clear_description();
  const std::string& description() const;
  void set_description(const std::string& value);
  void set_description(std::string&& value);
  void set_description(const char* value);
  void set_description(const char* value, size_t size);
  std::string* mutable_description();
  std::string* release_description();
  void set_allocated_description(std::string* description);
  private:
  const std::string& _internal_description() const;
  void _internal_set_description(const std::string& value);
  std::string* _internal_mutable_description();
  public:

  // required .message.Process_manual_operation_msg manual_operation = 1;
  bool has_manual_operation() const;
  private:
  bool _internal_has_manual_operation() const;
  public:
  void clear_manual_operation();
  const ::message::Process_manual_operation_msg& manual_operation() const;
  ::message::Process_manual_operation_msg* release_manual_operation();
  ::message::Process_manual_operation_msg* mutable_manual_operation();
  void set_allocated_manual_operation(::message::Process_manual_operation_msg* manual_operation);
  private:
  const ::message::Process_manual_operation_msg& _internal_manual_operation() const;
  ::message::Process_manual_operation_msg* _internal_mutable_manual_operation();
  public:
  void unsafe_arena_set_allocated_manual_operation(
      ::message::Process_manual_operation_msg* manual_operation);
  ::message::Process_manual_operation_msg* unsafe_arena_release_manual_operation();

  // @@protoc_insertion_point(class_scope:message.Manual_operation_data)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr description_;
  ::message::Process_manual_operation_msg* manual_operation_;
  friend struct ::TableStruct_log_5fprocess_2eproto;
};
// -------------------------------------------------------------------

class Log_data PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:message.Log_data) */ {
 public:
  inline Log_data() : Log_data(nullptr) {}
  virtual ~Log_data();

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

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

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

  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 Log_data& default_instance();

  enum DataCase {
    kStrLog = 2,
    kParkspaceLog = 3,
    kMeasureLog = 4,
    kDispatchLog = 5,
    kManualOperatorLog = 6,
    DATA_NOT_SET = 0,
  };

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

  friend void swap(Log_data& a, Log_data& b) {
    a.Swap(&b);
  }
  inline void Swap(Log_data* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Log_data* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

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

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

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) 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(Log_data* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "message.Log_data";
  }
  protected:
  explicit Log_data(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

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

  public:

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

  typedef Log_data_Severity Severity;
  static constexpr Severity INFO =
    Log_data_Severity_INFO;
  static constexpr Severity WARNING =
    Log_data_Severity_WARNING;
  static constexpr Severity ERROR =
    Log_data_Severity_ERROR;
  static inline bool Severity_IsValid(int value) {
    return Log_data_Severity_IsValid(value);
  }
  static constexpr Severity Severity_MIN =
    Log_data_Severity_Severity_MIN;
  static constexpr Severity Severity_MAX =
    Log_data_Severity_Severity_MAX;
  static constexpr int Severity_ARRAYSIZE =
    Log_data_Severity_Severity_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  Severity_descriptor() {
    return Log_data_Severity_descriptor();
  }
  template<typename T>
  static inline const std::string& Severity_Name(T enum_t_value) {
    static_assert(::std::is_same<T, Severity>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function Severity_Name.");
    return Log_data_Severity_Name(enum_t_value);
  }
  static inline bool Severity_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Severity* value) {
    return Log_data_Severity_Parse(name, value);
  }

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

  enum : int {
    kLogSeverityFieldNumber = 1,
    kStrLogFieldNumber = 2,
    kParkspaceLogFieldNumber = 3,
    kMeasureLogFieldNumber = 4,
    kDispatchLogFieldNumber = 5,
    kManualOperatorLogFieldNumber = 6,
  };
  // required .message.Log_data.Severity log_severity = 1;
  bool has_log_severity() const;
  private:
  bool _internal_has_log_severity() const;
  public:
  void clear_log_severity();
  ::message::Log_data_Severity log_severity() const;
  void set_log_severity(::message::Log_data_Severity value);
  private:
  ::message::Log_data_Severity _internal_log_severity() const;
  void _internal_set_log_severity(::message::Log_data_Severity value);
  public:

  // string str_log = 2;
  bool has_str_log() const;
  private:
  bool _internal_has_str_log() const;
  public:
  void clear_str_log();
  const std::string& str_log() const;
  void set_str_log(const std::string& value);
  void set_str_log(std::string&& value);
  void set_str_log(const char* value);
  void set_str_log(const char* value, size_t size);
  std::string* mutable_str_log();
  std::string* release_str_log();
  void set_allocated_str_log(std::string* str_log);
  private:
  const std::string& _internal_str_log() const;
  void _internal_set_str_log(const std::string& value);
  std::string* _internal_mutable_str_log();
  public:

  // .message.Parkspace_data parkspace_log = 3;
  bool has_parkspace_log() const;
  private:
  bool _internal_has_parkspace_log() const;
  public:
  void clear_parkspace_log();
  const ::message::Parkspace_data& parkspace_log() const;
  ::message::Parkspace_data* release_parkspace_log();
  ::message::Parkspace_data* mutable_parkspace_log();
  void set_allocated_parkspace_log(::message::Parkspace_data* parkspace_log);
  private:
  const ::message::Parkspace_data& _internal_parkspace_log() const;
  ::message::Parkspace_data* _internal_mutable_parkspace_log();
  public:
  void unsafe_arena_set_allocated_parkspace_log(
      ::message::Parkspace_data* parkspace_log);
  ::message::Parkspace_data* unsafe_arena_release_parkspace_log();

  // .message.Measure_data measure_log = 4;
  bool has_measure_log() const;
  private:
  bool _internal_has_measure_log() const;
  public:
  void clear_measure_log();
  const ::message::Measure_data& measure_log() const;
  ::message::Measure_data* release_measure_log();
  ::message::Measure_data* mutable_measure_log();
  void set_allocated_measure_log(::message::Measure_data* measure_log);
  private:
  const ::message::Measure_data& _internal_measure_log() const;
  ::message::Measure_data* _internal_mutable_measure_log();
  public:
  void unsafe_arena_set_allocated_measure_log(
      ::message::Measure_data* measure_log);
  ::message::Measure_data* unsafe_arena_release_measure_log();

  // .message.Dispatch_data dispatch_log = 5;
  bool has_dispatch_log() const;
  private:
  bool _internal_has_dispatch_log() const;
  public:
  void clear_dispatch_log();
  const ::message::Dispatch_data& dispatch_log() const;
  ::message::Dispatch_data* release_dispatch_log();
  ::message::Dispatch_data* mutable_dispatch_log();
  void set_allocated_dispatch_log(::message::Dispatch_data* dispatch_log);
  private:
  const ::message::Dispatch_data& _internal_dispatch_log() const;
  ::message::Dispatch_data* _internal_mutable_dispatch_log();
  public:
  void unsafe_arena_set_allocated_dispatch_log(
      ::message::Dispatch_data* dispatch_log);
  ::message::Dispatch_data* unsafe_arena_release_dispatch_log();

  // .message.Manual_operation_data manual_operator_log = 6;
  bool has_manual_operator_log() const;
  private:
  bool _internal_has_manual_operator_log() const;
  public:
  void clear_manual_operator_log();
  const ::message::Manual_operation_data& manual_operator_log() const;
  ::message::Manual_operation_data* release_manual_operator_log();
  ::message::Manual_operation_data* mutable_manual_operator_log();
  void set_allocated_manual_operator_log(::message::Manual_operation_data* manual_operator_log);
  private:
  const ::message::Manual_operation_data& _internal_manual_operator_log() const;
  ::message::Manual_operation_data* _internal_mutable_manual_operator_log();
  public:
  void unsafe_arena_set_allocated_manual_operator_log(
      ::message::Manual_operation_data* manual_operator_log);
  ::message::Manual_operation_data* unsafe_arena_release_manual_operator_log();

  void clear_data();
  DataCase data_case() const;
  // @@protoc_insertion_point(class_scope:message.Log_data)
 private:
  class _Internal;
  void set_has_str_log();
  void set_has_parkspace_log();
  void set_has_measure_log();
  void set_has_dispatch_log();
  void set_has_manual_operator_log();

  inline bool has_data() const;
  inline void clear_has_data();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  int log_severity_;
  union DataUnion {
    DataUnion() {}
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr str_log_;
    ::message::Parkspace_data* parkspace_log_;
    ::message::Measure_data* measure_log_;
    ::message::Dispatch_data* dispatch_log_;
    ::message::Manual_operation_data* manual_operator_log_;
  } data_;
  ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];

  friend struct ::TableStruct_log_5fprocess_2eproto;
};
// -------------------------------------------------------------------

class Process_log PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:message.Process_log) */ {
 public:
  inline Process_log() : Process_log(nullptr) {}
  virtual ~Process_log();

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

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

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

  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 Process_log& default_instance();

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

  friend void swap(Process_log& a, Process_log& b) {
    a.Swap(&b);
  }
  inline void Swap(Process_log* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Process_log* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

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

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

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) 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(Process_log* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "message.Process_log";
  }
  protected:
  explicit Process_log(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

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

  public:

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

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

  enum : int {
    kLogDataFieldNumber = 2,
    kProcessTypeFieldNumber = 1,
  };
  // repeated .message.Log_data log_data = 2;
  int log_data_size() const;
  private:
  int _internal_log_data_size() const;
  public:
  void clear_log_data();
  ::message::Log_data* mutable_log_data(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::message::Log_data >*
      mutable_log_data();
  private:
  const ::message::Log_data& _internal_log_data(int index) const;
  ::message::Log_data* _internal_add_log_data();
  public:
  const ::message::Log_data& log_data(int index) const;
  ::message::Log_data* add_log_data();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::message::Log_data >&
      log_data() const;

  // required .message.Process_type process_type = 1;
  bool has_process_type() const;
  private:
  bool _internal_has_process_type() const;
  public:
  void clear_process_type();
  ::message::Process_type process_type() const;
  void set_process_type(::message::Process_type value);
  private:
  ::message::Process_type _internal_process_type() const;
  void _internal_set_process_type(::message::Process_type value);
  public:

  // @@protoc_insertion_point(class_scope:message.Process_log)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::message::Log_data > log_data_;
  int process_type_;
  friend struct ::TableStruct_log_5fprocess_2eproto;
};
// ===================================================================


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

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

// optional .message.Parkspace_allocation_request_msg alloc_request = 1;
inline bool Parkspace_data::_internal_has_alloc_request() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || alloc_request_ != nullptr);
  return value;
}
inline bool Parkspace_data::has_alloc_request() const {
  return _internal_has_alloc_request();
}
inline const ::message::Parkspace_allocation_request_msg& Parkspace_data::_internal_alloc_request() const {
  const ::message::Parkspace_allocation_request_msg* p = alloc_request_;
  return p != nullptr ? *p : *reinterpret_cast<const ::message::Parkspace_allocation_request_msg*>(
      &::message::_Parkspace_allocation_request_msg_default_instance_);
}
inline const ::message::Parkspace_allocation_request_msg& Parkspace_data::alloc_request() const {
  // @@protoc_insertion_point(field_get:message.Parkspace_data.alloc_request)
  return _internal_alloc_request();
}
inline void Parkspace_data::unsafe_arena_set_allocated_alloc_request(
    ::message::Parkspace_allocation_request_msg* alloc_request) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(alloc_request_);
  }
  alloc_request_ = alloc_request;
  if (alloc_request) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:message.Parkspace_data.alloc_request)
}
inline ::message::Parkspace_allocation_request_msg* Parkspace_data::release_alloc_request() {
  _has_bits_[0] &= ~0x00000002u;
  ::message::Parkspace_allocation_request_msg* temp = alloc_request_;
  alloc_request_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::message::Parkspace_allocation_request_msg* Parkspace_data::unsafe_arena_release_alloc_request() {
  // @@protoc_insertion_point(field_release:message.Parkspace_data.alloc_request)
  _has_bits_[0] &= ~0x00000002u;
  ::message::Parkspace_allocation_request_msg* temp = alloc_request_;
  alloc_request_ = nullptr;
  return temp;
}
inline ::message::Parkspace_allocation_request_msg* Parkspace_data::_internal_mutable_alloc_request() {
  _has_bits_[0] |= 0x00000002u;
  if (alloc_request_ == nullptr) {
    auto* p = CreateMaybeMessage<::message::Parkspace_allocation_request_msg>(GetArena());
    alloc_request_ = p;
  }
  return alloc_request_;
}
inline ::message::Parkspace_allocation_request_msg* Parkspace_data::mutable_alloc_request() {
  // @@protoc_insertion_point(field_mutable:message.Parkspace_data.alloc_request)
  return _internal_mutable_alloc_request();
}
inline void Parkspace_data::set_allocated_alloc_request(::message::Parkspace_allocation_request_msg* alloc_request) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(alloc_request_);
  }
  if (alloc_request) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(alloc_request)->GetArena();
    if (message_arena != submessage_arena) {
      alloc_request = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, alloc_request, submessage_arena);
    }
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  alloc_request_ = alloc_request;
  // @@protoc_insertion_point(field_set_allocated:message.Parkspace_data.alloc_request)
}

// optional .message.Parkspace_allocation_response_msg alloc_response = 2;
inline bool Parkspace_data::_internal_has_alloc_response() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || alloc_response_ != nullptr);
  return value;
}
inline bool Parkspace_data::has_alloc_response() const {
  return _internal_has_alloc_response();
}
inline const ::message::Parkspace_allocation_response_msg& Parkspace_data::_internal_alloc_response() const {
  const ::message::Parkspace_allocation_response_msg* p = alloc_response_;
  return p != nullptr ? *p : *reinterpret_cast<const ::message::Parkspace_allocation_response_msg*>(
      &::message::_Parkspace_allocation_response_msg_default_instance_);
}
inline const ::message::Parkspace_allocation_response_msg& Parkspace_data::alloc_response() const {
  // @@protoc_insertion_point(field_get:message.Parkspace_data.alloc_response)
  return _internal_alloc_response();
}
inline void Parkspace_data::unsafe_arena_set_allocated_alloc_response(
    ::message::Parkspace_allocation_response_msg* alloc_response) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(alloc_response_);
  }
  alloc_response_ = alloc_response;
  if (alloc_response) {
    _has_bits_[0] |= 0x00000004u;
  } else {
    _has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:message.Parkspace_data.alloc_response)
}
inline ::message::Parkspace_allocation_response_msg* Parkspace_data::release_alloc_response() {
  _has_bits_[0] &= ~0x00000004u;
  ::message::Parkspace_allocation_response_msg* temp = alloc_response_;
  alloc_response_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::message::Parkspace_allocation_response_msg* Parkspace_data::unsafe_arena_release_alloc_response() {
  // @@protoc_insertion_point(field_release:message.Parkspace_data.alloc_response)
  _has_bits_[0] &= ~0x00000004u;
  ::message::Parkspace_allocation_response_msg* temp = alloc_response_;
  alloc_response_ = nullptr;
  return temp;
}
inline ::message::Parkspace_allocation_response_msg* Parkspace_data::_internal_mutable_alloc_response() {
  _has_bits_[0] |= 0x00000004u;
  if (alloc_response_ == nullptr) {
    auto* p = CreateMaybeMessage<::message::Parkspace_allocation_response_msg>(GetArena());
    alloc_response_ = p;
  }
  return alloc_response_;
}
inline ::message::Parkspace_allocation_response_msg* Parkspace_data::mutable_alloc_response() {
  // @@protoc_insertion_point(field_mutable:message.Parkspace_data.alloc_response)
  return _internal_mutable_alloc_response();
}
inline void Parkspace_data::set_allocated_alloc_response(::message::Parkspace_allocation_response_msg* alloc_response) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(alloc_response_);
  }
  if (alloc_response) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(alloc_response)->GetArena();
    if (message_arena != submessage_arena) {
      alloc_response = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, alloc_response, submessage_arena);
    }
    _has_bits_[0] |= 0x00000004u;
  } else {
    _has_bits_[0] &= ~0x00000004u;
  }
  alloc_response_ = alloc_response;
  // @@protoc_insertion_point(field_set_allocated:message.Parkspace_data.alloc_response)
}

// optional .message.Parkspace_search_request_msg search_request = 3;
inline bool Parkspace_data::_internal_has_search_request() const {
  bool value = (_has_bits_[0] & 0x00000008u) != 0;
  PROTOBUF_ASSUME(!value || search_request_ != nullptr);
  return value;
}
inline bool Parkspace_data::has_search_request() const {
  return _internal_has_search_request();
}
inline const ::message::Parkspace_search_request_msg& Parkspace_data::_internal_search_request() const {
  const ::message::Parkspace_search_request_msg* p = search_request_;
  return p != nullptr ? *p : *reinterpret_cast<const ::message::Parkspace_search_request_msg*>(
      &::message::_Parkspace_search_request_msg_default_instance_);
}
inline const ::message::Parkspace_search_request_msg& Parkspace_data::search_request() const {
  // @@protoc_insertion_point(field_get:message.Parkspace_data.search_request)
  return _internal_search_request();
}
inline void Parkspace_data::unsafe_arena_set_allocated_search_request(
    ::message::Parkspace_search_request_msg* search_request) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(search_request_);
  }
  search_request_ = search_request;
  if (search_request) {
    _has_bits_[0] |= 0x00000008u;
  } else {
    _has_bits_[0] &= ~0x00000008u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:message.Parkspace_data.search_request)
}
inline ::message::Parkspace_search_request_msg* Parkspace_data::release_search_request() {
  _has_bits_[0] &= ~0x00000008u;
  ::message::Parkspace_search_request_msg* temp = search_request_;
  search_request_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::message::Parkspace_search_request_msg* Parkspace_data::unsafe_arena_release_search_request() {
  // @@protoc_insertion_point(field_release:message.Parkspace_data.search_request)
  _has_bits_[0] &= ~0x00000008u;
  ::message::Parkspace_search_request_msg* temp = search_request_;
  search_request_ = nullptr;
  return temp;
}
inline ::message::Parkspace_search_request_msg* Parkspace_data::_internal_mutable_search_request() {
  _has_bits_[0] |= 0x00000008u;
  if (search_request_ == nullptr) {
    auto* p = CreateMaybeMessage<::message::Parkspace_search_request_msg>(GetArena());
    search_request_ = p;
  }
  return search_request_;
}
inline ::message::Parkspace_search_request_msg* Parkspace_data::mutable_search_request() {
  // @@protoc_insertion_point(field_mutable:message.Parkspace_data.search_request)
  return _internal_mutable_search_request();
}
inline void Parkspace_data::set_allocated_search_request(::message::Parkspace_search_request_msg* search_request) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(search_request_);
  }
  if (search_request) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(search_request)->GetArena();
    if (message_arena != submessage_arena) {
      search_request = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, search_request, submessage_arena);
    }
    _has_bits_[0] |= 0x00000008u;
  } else {
    _has_bits_[0] &= ~0x00000008u;
  }
  search_request_ = search_request;
  // @@protoc_insertion_point(field_set_allocated:message.Parkspace_data.search_request)
}

// optional .message.Parkspace_search_response_msg search_response = 4;
inline bool Parkspace_data::_internal_has_search_response() const {
  bool value = (_has_bits_[0] & 0x00000010u) != 0;
  PROTOBUF_ASSUME(!value || search_response_ != nullptr);
  return value;
}
inline bool Parkspace_data::has_search_response() const {
  return _internal_has_search_response();
}
inline const ::message::Parkspace_search_response_msg& Parkspace_data::_internal_search_response() const {
  const ::message::Parkspace_search_response_msg* p = search_response_;
  return p != nullptr ? *p : *reinterpret_cast<const ::message::Parkspace_search_response_msg*>(
      &::message::_Parkspace_search_response_msg_default_instance_);
}
inline const ::message::Parkspace_search_response_msg& Parkspace_data::search_response() const {
  // @@protoc_insertion_point(field_get:message.Parkspace_data.search_response)
  return _internal_search_response();
}
inline void Parkspace_data::unsafe_arena_set_allocated_search_response(
    ::message::Parkspace_search_response_msg* search_response) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(search_response_);
  }
  search_response_ = search_response;
  if (search_response) {
    _has_bits_[0] |= 0x00000010u;
  } else {
    _has_bits_[0] &= ~0x00000010u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:message.Parkspace_data.search_response)
}
inline ::message::Parkspace_search_response_msg* Parkspace_data::release_search_response() {
  _has_bits_[0] &= ~0x00000010u;
  ::message::Parkspace_search_response_msg* temp = search_response_;
  search_response_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::message::Parkspace_search_response_msg* Parkspace_data::unsafe_arena_release_search_response() {
  // @@protoc_insertion_point(field_release:message.Parkspace_data.search_response)
  _has_bits_[0] &= ~0x00000010u;
  ::message::Parkspace_search_response_msg* temp = search_response_;
  search_response_ = nullptr;
  return temp;
}
inline ::message::Parkspace_search_response_msg* Parkspace_data::_internal_mutable_search_response() {
  _has_bits_[0] |= 0x00000010u;
  if (search_response_ == nullptr) {
    auto* p = CreateMaybeMessage<::message::Parkspace_search_response_msg>(GetArena());
    search_response_ = p;
  }
  return search_response_;
}
inline ::message::Parkspace_search_response_msg* Parkspace_data::mutable_search_response() {
  // @@protoc_insertion_point(field_mutable:message.Parkspace_data.search_response)
  return _internal_mutable_search_response();
}
inline void Parkspace_data::set_allocated_search_response(::message::Parkspace_search_response_msg* search_response) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(search_response_);
  }
  if (search_response) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(search_response)->GetArena();
    if (message_arena != submessage_arena) {
      search_response = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, search_response, submessage_arena);
    }
    _has_bits_[0] |= 0x00000010u;
  } else {
    _has_bits_[0] &= ~0x00000010u;
  }
  search_response_ = search_response;
  // @@protoc_insertion_point(field_set_allocated:message.Parkspace_data.search_response)
}

// optional .message.Parkspace_release_request_msg release_request = 5;
inline bool Parkspace_data::_internal_has_release_request() const {
  bool value = (_has_bits_[0] & 0x00000020u) != 0;
  PROTOBUF_ASSUME(!value || release_request_ != nullptr);
  return value;
}
inline bool Parkspace_data::has_release_request() const {
  return _internal_has_release_request();
}
inline const ::message::Parkspace_release_request_msg& Parkspace_data::_internal_release_request() const {
  const ::message::Parkspace_release_request_msg* p = release_request_;
  return p != nullptr ? *p : *reinterpret_cast<const ::message::Parkspace_release_request_msg*>(
      &::message::_Parkspace_release_request_msg_default_instance_);
}
inline const ::message::Parkspace_release_request_msg& Parkspace_data::release_request() const {
  // @@protoc_insertion_point(field_get:message.Parkspace_data.release_request)
  return _internal_release_request();
}
inline void Parkspace_data::unsafe_arena_set_allocated_release_request(
    ::message::Parkspace_release_request_msg* release_request) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(release_request_);
  }
  release_request_ = release_request;
  if (release_request) {
    _has_bits_[0] |= 0x00000020u;
  } else {
    _has_bits_[0] &= ~0x00000020u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:message.Parkspace_data.release_request)
}
inline ::message::Parkspace_release_request_msg* Parkspace_data::release_release_request() {
  _has_bits_[0] &= ~0x00000020u;
  ::message::Parkspace_release_request_msg* temp = release_request_;
  release_request_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::message::Parkspace_release_request_msg* Parkspace_data::unsafe_arena_release_release_request() {
  // @@protoc_insertion_point(field_release:message.Parkspace_data.release_request)
  _has_bits_[0] &= ~0x00000020u;
  ::message::Parkspace_release_request_msg* temp = release_request_;
  release_request_ = nullptr;
  return temp;
}
inline ::message::Parkspace_release_request_msg* Parkspace_data::_internal_mutable_release_request() {
  _has_bits_[0] |= 0x00000020u;
  if (release_request_ == nullptr) {
    auto* p = CreateMaybeMessage<::message::Parkspace_release_request_msg>(GetArena());
    release_request_ = p;
  }
  return release_request_;
}
inline ::message::Parkspace_release_request_msg* Parkspace_data::mutable_release_request() {
  // @@protoc_insertion_point(field_mutable:message.Parkspace_data.release_request)
  return _internal_mutable_release_request();
}
inline void Parkspace_data::set_allocated_release_request(::message::Parkspace_release_request_msg* release_request) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(release_request_);
  }
  if (release_request) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(release_request)->GetArena();
    if (message_arena != submessage_arena) {
      release_request = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, release_request, submessage_arena);
    }
    _has_bits_[0] |= 0x00000020u;
  } else {
    _has_bits_[0] &= ~0x00000020u;
  }
  release_request_ = release_request;
  // @@protoc_insertion_point(field_set_allocated:message.Parkspace_data.release_request)
}

// optional .message.Parkspace_release_response_msg release_response = 6;
inline bool Parkspace_data::_internal_has_release_response() const {
  bool value = (_has_bits_[0] & 0x00000040u) != 0;
  PROTOBUF_ASSUME(!value || release_response_ != nullptr);
  return value;
}
inline bool Parkspace_data::has_release_response() const {
  return _internal_has_release_response();
}
inline const ::message::Parkspace_release_response_msg& Parkspace_data::_internal_release_response() const {
  const ::message::Parkspace_release_response_msg* p = release_response_;
  return p != nullptr ? *p : *reinterpret_cast<const ::message::Parkspace_release_response_msg*>(
      &::message::_Parkspace_release_response_msg_default_instance_);
}
inline const ::message::Parkspace_release_response_msg& Parkspace_data::release_response() const {
  // @@protoc_insertion_point(field_get:message.Parkspace_data.release_response)
  return _internal_release_response();
}
inline void Parkspace_data::unsafe_arena_set_allocated_release_response(
    ::message::Parkspace_release_response_msg* release_response) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(release_response_);
  }
  release_response_ = release_response;
  if (release_response) {
    _has_bits_[0] |= 0x00000040u;
  } else {
    _has_bits_[0] &= ~0x00000040u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:message.Parkspace_data.release_response)
}
inline ::message::Parkspace_release_response_msg* Parkspace_data::release_release_response() {
  _has_bits_[0] &= ~0x00000040u;
  ::message::Parkspace_release_response_msg* temp = release_response_;
  release_response_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::message::Parkspace_release_response_msg* Parkspace_data::unsafe_arena_release_release_response() {
  // @@protoc_insertion_point(field_release:message.Parkspace_data.release_response)
  _has_bits_[0] &= ~0x00000040u;
  ::message::Parkspace_release_response_msg* temp = release_response_;
  release_response_ = nullptr;
  return temp;
}
inline ::message::Parkspace_release_response_msg* Parkspace_data::_internal_mutable_release_response() {
  _has_bits_[0] |= 0x00000040u;
  if (release_response_ == nullptr) {
    auto* p = CreateMaybeMessage<::message::Parkspace_release_response_msg>(GetArena());
    release_response_ = p;
  }
  return release_response_;
}
inline ::message::Parkspace_release_response_msg* Parkspace_data::mutable_release_response() {
  // @@protoc_insertion_point(field_mutable:message.Parkspace_data.release_response)
  return _internal_mutable_release_response();
}
inline void Parkspace_data::set_allocated_release_response(::message::Parkspace_release_response_msg* release_response) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(release_response_);
  }
  if (release_response) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(release_response)->GetArena();
    if (message_arena != submessage_arena) {
      release_response = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, release_response, submessage_arena);
    }
    _has_bits_[0] |= 0x00000040u;
  } else {
    _has_bits_[0] &= ~0x00000040u;
  }
  release_response_ = release_response;
  // @@protoc_insertion_point(field_set_allocated:message.Parkspace_data.release_response)
}

// optional .message.Parkspace_confirm_alloc_request_msg confirm_request = 7;
inline bool Parkspace_data::_internal_has_confirm_request() const {
  bool value = (_has_bits_[0] & 0x00000080u) != 0;
  PROTOBUF_ASSUME(!value || confirm_request_ != nullptr);
  return value;
}
inline bool Parkspace_data::has_confirm_request() const {
  return _internal_has_confirm_request();
}
inline const ::message::Parkspace_confirm_alloc_request_msg& Parkspace_data::_internal_confirm_request() const {
  const ::message::Parkspace_confirm_alloc_request_msg* p = confirm_request_;
  return p != nullptr ? *p : *reinterpret_cast<const ::message::Parkspace_confirm_alloc_request_msg*>(
      &::message::_Parkspace_confirm_alloc_request_msg_default_instance_);
}
inline const ::message::Parkspace_confirm_alloc_request_msg& Parkspace_data::confirm_request() const {
  // @@protoc_insertion_point(field_get:message.Parkspace_data.confirm_request)
  return _internal_confirm_request();
}
inline void Parkspace_data::unsafe_arena_set_allocated_confirm_request(
    ::message::Parkspace_confirm_alloc_request_msg* confirm_request) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(confirm_request_);
  }
  confirm_request_ = confirm_request;
  if (confirm_request) {
    _has_bits_[0] |= 0x00000080u;
  } else {
    _has_bits_[0] &= ~0x00000080u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:message.Parkspace_data.confirm_request)
}
inline ::message::Parkspace_confirm_alloc_request_msg* Parkspace_data::release_confirm_request() {
  _has_bits_[0] &= ~0x00000080u;
  ::message::Parkspace_confirm_alloc_request_msg* temp = confirm_request_;
  confirm_request_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::message::Parkspace_confirm_alloc_request_msg* Parkspace_data::unsafe_arena_release_confirm_request() {
  // @@protoc_insertion_point(field_release:message.Parkspace_data.confirm_request)
  _has_bits_[0] &= ~0x00000080u;
  ::message::Parkspace_confirm_alloc_request_msg* temp = confirm_request_;
  confirm_request_ = nullptr;
  return temp;
}
inline ::message::Parkspace_confirm_alloc_request_msg* Parkspace_data::_internal_mutable_confirm_request() {
  _has_bits_[0] |= 0x00000080u;
  if (confirm_request_ == nullptr) {
    auto* p = CreateMaybeMessage<::message::Parkspace_confirm_alloc_request_msg>(GetArena());
    confirm_request_ = p;
  }
  return confirm_request_;
}
inline ::message::Parkspace_confirm_alloc_request_msg* Parkspace_data::mutable_confirm_request() {
  // @@protoc_insertion_point(field_mutable:message.Parkspace_data.confirm_request)
  return _internal_mutable_confirm_request();
}
inline void Parkspace_data::set_allocated_confirm_request(::message::Parkspace_confirm_alloc_request_msg* confirm_request) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(confirm_request_);
  }
  if (confirm_request) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(confirm_request)->GetArena();
    if (message_arena != submessage_arena) {
      confirm_request = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, confirm_request, submessage_arena);
    }
    _has_bits_[0] |= 0x00000080u;
  } else {
    _has_bits_[0] &= ~0x00000080u;
  }
  confirm_request_ = confirm_request;
  // @@protoc_insertion_point(field_set_allocated:message.Parkspace_data.confirm_request)
}

// optional .message.Parkspace_confirm_alloc_response_msg confirm_response = 8;
inline bool Parkspace_data::_internal_has_confirm_response() const {
  bool value = (_has_bits_[0] & 0x00000100u) != 0;
  PROTOBUF_ASSUME(!value || confirm_response_ != nullptr);
  return value;
}
inline bool Parkspace_data::has_confirm_response() const {
  return _internal_has_confirm_response();
}
inline const ::message::Parkspace_confirm_alloc_response_msg& Parkspace_data::_internal_confirm_response() const {
  const ::message::Parkspace_confirm_alloc_response_msg* p = confirm_response_;
  return p != nullptr ? *p : *reinterpret_cast<const ::message::Parkspace_confirm_alloc_response_msg*>(
      &::message::_Parkspace_confirm_alloc_response_msg_default_instance_);
}
inline const ::message::Parkspace_confirm_alloc_response_msg& Parkspace_data::confirm_response() const {
  // @@protoc_insertion_point(field_get:message.Parkspace_data.confirm_response)
  return _internal_confirm_response();
}
inline void Parkspace_data::unsafe_arena_set_allocated_confirm_response(
    ::message::Parkspace_confirm_alloc_response_msg* confirm_response) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(confirm_response_);
  }
  confirm_response_ = confirm_response;
  if (confirm_response) {
    _has_bits_[0] |= 0x00000100u;
  } else {
    _has_bits_[0] &= ~0x00000100u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:message.Parkspace_data.confirm_response)
}
inline ::message::Parkspace_confirm_alloc_response_msg* Parkspace_data::release_confirm_response() {
  _has_bits_[0] &= ~0x00000100u;
  ::message::Parkspace_confirm_alloc_response_msg* temp = confirm_response_;
  confirm_response_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::message::Parkspace_confirm_alloc_response_msg* Parkspace_data::unsafe_arena_release_confirm_response() {
  // @@protoc_insertion_point(field_release:message.Parkspace_data.confirm_response)
  _has_bits_[0] &= ~0x00000100u;
  ::message::Parkspace_confirm_alloc_response_msg* temp = confirm_response_;
  confirm_response_ = nullptr;
  return temp;
}
inline ::message::Parkspace_confirm_alloc_response_msg* Parkspace_data::_internal_mutable_confirm_response() {
  _has_bits_[0] |= 0x00000100u;
  if (confirm_response_ == nullptr) {
    auto* p = CreateMaybeMessage<::message::Parkspace_confirm_alloc_response_msg>(GetArena());
    confirm_response_ = p;
  }
  return confirm_response_;
}
inline ::message::Parkspace_confirm_alloc_response_msg* Parkspace_data::mutable_confirm_response() {
  // @@protoc_insertion_point(field_mutable:message.Parkspace_data.confirm_response)
  return _internal_mutable_confirm_response();
}
inline void Parkspace_data::set_allocated_confirm_response(::message::Parkspace_confirm_alloc_response_msg* confirm_response) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(confirm_response_);
  }
  if (confirm_response) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(confirm_response)->GetArena();
    if (message_arena != submessage_arena) {
      confirm_response = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, confirm_response, submessage_arena);
    }
    _has_bits_[0] |= 0x00000100u;
  } else {
    _has_bits_[0] &= ~0x00000100u;
  }
  confirm_response_ = confirm_response;
  // @@protoc_insertion_point(field_set_allocated:message.Parkspace_data.confirm_response)
}

// optional string description = 9;
inline bool Parkspace_data::_internal_has_description() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Parkspace_data::has_description() const {
  return _internal_has_description();
}
inline void Parkspace_data::clear_description() {
  description_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Parkspace_data::description() const {
  // @@protoc_insertion_point(field_get:message.Parkspace_data.description)
  return _internal_description();
}
inline void Parkspace_data::set_description(const std::string& value) {
  _internal_set_description(value);
  // @@protoc_insertion_point(field_set:message.Parkspace_data.description)
}
inline std::string* Parkspace_data::mutable_description() {
  // @@protoc_insertion_point(field_mutable:message.Parkspace_data.description)
  return _internal_mutable_description();
}
inline const std::string& Parkspace_data::_internal_description() const {
  return description_.Get();
}
inline void Parkspace_data::_internal_set_description(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  description_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void Parkspace_data::set_description(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  description_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:message.Parkspace_data.description)
}
inline void Parkspace_data::set_description(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  description_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:message.Parkspace_data.description)
}
inline void Parkspace_data::set_description(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000001u;
  description_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:message.Parkspace_data.description)
}
inline std::string* Parkspace_data::_internal_mutable_description() {
  _has_bits_[0] |= 0x00000001u;
  return description_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* Parkspace_data::release_description() {
  // @@protoc_insertion_point(field_release:message.Parkspace_data.description)
  if (!_internal_has_description()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return description_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Parkspace_data::set_allocated_description(std::string* description) {
  if (description != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  description_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), description,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:message.Parkspace_data.description)
}

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

// Measure_data

// optional .message.Measure_request_msg request = 1;
inline bool Measure_data::_internal_has_request() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || request_ != nullptr);
  return value;
}
inline bool Measure_data::has_request() const {
  return _internal_has_request();
}
inline const ::message::Measure_request_msg& Measure_data::_internal_request() const {
  const ::message::Measure_request_msg* p = request_;
  return p != nullptr ? *p : *reinterpret_cast<const ::message::Measure_request_msg*>(
      &::message::_Measure_request_msg_default_instance_);
}
inline const ::message::Measure_request_msg& Measure_data::request() const {
  // @@protoc_insertion_point(field_get:message.Measure_data.request)
  return _internal_request();
}
inline void Measure_data::unsafe_arena_set_allocated_request(
    ::message::Measure_request_msg* request) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(request_);
  }
  request_ = request;
  if (request) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:message.Measure_data.request)
}
inline ::message::Measure_request_msg* Measure_data::release_request() {
  _has_bits_[0] &= ~0x00000002u;
  ::message::Measure_request_msg* temp = request_;
  request_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::message::Measure_request_msg* Measure_data::unsafe_arena_release_request() {
  // @@protoc_insertion_point(field_release:message.Measure_data.request)
  _has_bits_[0] &= ~0x00000002u;
  ::message::Measure_request_msg* temp = request_;
  request_ = nullptr;
  return temp;
}
inline ::message::Measure_request_msg* Measure_data::_internal_mutable_request() {
  _has_bits_[0] |= 0x00000002u;
  if (request_ == nullptr) {
    auto* p = CreateMaybeMessage<::message::Measure_request_msg>(GetArena());
    request_ = p;
  }
  return request_;
}
inline ::message::Measure_request_msg* Measure_data::mutable_request() {
  // @@protoc_insertion_point(field_mutable:message.Measure_data.request)
  return _internal_mutable_request();
}
inline void Measure_data::set_allocated_request(::message::Measure_request_msg* request) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(request_);
  }
  if (request) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(request)->GetArena();
    if (message_arena != submessage_arena) {
      request = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, request, submessage_arena);
    }
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  request_ = request;
  // @@protoc_insertion_point(field_set_allocated:message.Measure_data.request)
}

// optional .message.Measure_response_msg response = 2;
inline bool Measure_data::_internal_has_response() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || response_ != nullptr);
  return value;
}
inline bool Measure_data::has_response() const {
  return _internal_has_response();
}
inline const ::message::Measure_response_msg& Measure_data::_internal_response() const {
  const ::message::Measure_response_msg* p = response_;
  return p != nullptr ? *p : *reinterpret_cast<const ::message::Measure_response_msg*>(
      &::message::_Measure_response_msg_default_instance_);
}
inline const ::message::Measure_response_msg& Measure_data::response() const {
  // @@protoc_insertion_point(field_get:message.Measure_data.response)
  return _internal_response();
}
inline void Measure_data::unsafe_arena_set_allocated_response(
    ::message::Measure_response_msg* response) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(response_);
  }
  response_ = response;
  if (response) {
    _has_bits_[0] |= 0x00000004u;
  } else {
    _has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:message.Measure_data.response)
}
inline ::message::Measure_response_msg* Measure_data::release_response() {
  _has_bits_[0] &= ~0x00000004u;
  ::message::Measure_response_msg* temp = response_;
  response_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::message::Measure_response_msg* Measure_data::unsafe_arena_release_response() {
  // @@protoc_insertion_point(field_release:message.Measure_data.response)
  _has_bits_[0] &= ~0x00000004u;
  ::message::Measure_response_msg* temp = response_;
  response_ = nullptr;
  return temp;
}
inline ::message::Measure_response_msg* Measure_data::_internal_mutable_response() {
  _has_bits_[0] |= 0x00000004u;
  if (response_ == nullptr) {
    auto* p = CreateMaybeMessage<::message::Measure_response_msg>(GetArena());
    response_ = p;
  }
  return response_;
}
inline ::message::Measure_response_msg* Measure_data::mutable_response() {
  // @@protoc_insertion_point(field_mutable:message.Measure_data.response)
  return _internal_mutable_response();
}
inline void Measure_data::set_allocated_response(::message::Measure_response_msg* response) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(response_);
  }
  if (response) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(response)->GetArena();
    if (message_arena != submessage_arena) {
      response = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, response, submessage_arena);
    }
    _has_bits_[0] |= 0x00000004u;
  } else {
    _has_bits_[0] &= ~0x00000004u;
  }
  response_ = response;
  // @@protoc_insertion_point(field_set_allocated:message.Measure_data.response)
}

// optional string description = 3;
inline bool Measure_data::_internal_has_description() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Measure_data::has_description() const {
  return _internal_has_description();
}
inline void Measure_data::clear_description() {
  description_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Measure_data::description() const {
  // @@protoc_insertion_point(field_get:message.Measure_data.description)
  return _internal_description();
}
inline void Measure_data::set_description(const std::string& value) {
  _internal_set_description(value);
  // @@protoc_insertion_point(field_set:message.Measure_data.description)
}
inline std::string* Measure_data::mutable_description() {
  // @@protoc_insertion_point(field_mutable:message.Measure_data.description)
  return _internal_mutable_description();
}
inline const std::string& Measure_data::_internal_description() const {
  return description_.Get();
}
inline void Measure_data::_internal_set_description(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  description_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void Measure_data::set_description(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  description_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:message.Measure_data.description)
}
inline void Measure_data::set_description(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  description_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:message.Measure_data.description)
}
inline void Measure_data::set_description(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000001u;
  description_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:message.Measure_data.description)
}
inline std::string* Measure_data::_internal_mutable_description() {
  _has_bits_[0] |= 0x00000001u;
  return description_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* Measure_data::release_description() {
  // @@protoc_insertion_point(field_release:message.Measure_data.description)
  if (!_internal_has_description()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return description_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Measure_data::set_allocated_description(std::string* description) {
  if (description != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  description_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), description,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:message.Measure_data.description)
}

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

// Dispatch_data

// optional .message.Dispatch_request_msg request = 1;
inline bool Dispatch_data::_internal_has_request() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || request_ != nullptr);
  return value;
}
inline bool Dispatch_data::has_request() const {
  return _internal_has_request();
}
inline const ::message::Dispatch_request_msg& Dispatch_data::_internal_request() const {
  const ::message::Dispatch_request_msg* p = request_;
  return p != nullptr ? *p : *reinterpret_cast<const ::message::Dispatch_request_msg*>(
      &::message::_Dispatch_request_msg_default_instance_);
}
inline const ::message::Dispatch_request_msg& Dispatch_data::request() const {
  // @@protoc_insertion_point(field_get:message.Dispatch_data.request)
  return _internal_request();
}
inline void Dispatch_data::unsafe_arena_set_allocated_request(
    ::message::Dispatch_request_msg* request) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(request_);
  }
  request_ = request;
  if (request) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:message.Dispatch_data.request)
}
inline ::message::Dispatch_request_msg* Dispatch_data::release_request() {
  _has_bits_[0] &= ~0x00000002u;
  ::message::Dispatch_request_msg* temp = request_;
  request_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::message::Dispatch_request_msg* Dispatch_data::unsafe_arena_release_request() {
  // @@protoc_insertion_point(field_release:message.Dispatch_data.request)
  _has_bits_[0] &= ~0x00000002u;
  ::message::Dispatch_request_msg* temp = request_;
  request_ = nullptr;
  return temp;
}
inline ::message::Dispatch_request_msg* Dispatch_data::_internal_mutable_request() {
  _has_bits_[0] |= 0x00000002u;
  if (request_ == nullptr) {
    auto* p = CreateMaybeMessage<::message::Dispatch_request_msg>(GetArena());
    request_ = p;
  }
  return request_;
}
inline ::message::Dispatch_request_msg* Dispatch_data::mutable_request() {
  // @@protoc_insertion_point(field_mutable:message.Dispatch_data.request)
  return _internal_mutable_request();
}
inline void Dispatch_data::set_allocated_request(::message::Dispatch_request_msg* request) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(request_);
  }
  if (request) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(request)->GetArena();
    if (message_arena != submessage_arena) {
      request = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, request, submessage_arena);
    }
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  request_ = request;
  // @@protoc_insertion_point(field_set_allocated:message.Dispatch_data.request)
}

// optional .message.Dispatch_response_msg response = 2;
inline bool Dispatch_data::_internal_has_response() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || response_ != nullptr);
  return value;
}
inline bool Dispatch_data::has_response() const {
  return _internal_has_response();
}
inline const ::message::Dispatch_response_msg& Dispatch_data::_internal_response() const {
  const ::message::Dispatch_response_msg* p = response_;
  return p != nullptr ? *p : *reinterpret_cast<const ::message::Dispatch_response_msg*>(
      &::message::_Dispatch_response_msg_default_instance_);
}
inline const ::message::Dispatch_response_msg& Dispatch_data::response() const {
  // @@protoc_insertion_point(field_get:message.Dispatch_data.response)
  return _internal_response();
}
inline void Dispatch_data::unsafe_arena_set_allocated_response(
    ::message::Dispatch_response_msg* response) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(response_);
  }
  response_ = response;
  if (response) {
    _has_bits_[0] |= 0x00000004u;
  } else {
    _has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:message.Dispatch_data.response)
}
inline ::message::Dispatch_response_msg* Dispatch_data::release_response() {
  _has_bits_[0] &= ~0x00000004u;
  ::message::Dispatch_response_msg* temp = response_;
  response_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::message::Dispatch_response_msg* Dispatch_data::unsafe_arena_release_response() {
  // @@protoc_insertion_point(field_release:message.Dispatch_data.response)
  _has_bits_[0] &= ~0x00000004u;
  ::message::Dispatch_response_msg* temp = response_;
  response_ = nullptr;
  return temp;
}
inline ::message::Dispatch_response_msg* Dispatch_data::_internal_mutable_response() {
  _has_bits_[0] |= 0x00000004u;
  if (response_ == nullptr) {
    auto* p = CreateMaybeMessage<::message::Dispatch_response_msg>(GetArena());
    response_ = p;
  }
  return response_;
}
inline ::message::Dispatch_response_msg* Dispatch_data::mutable_response() {
  // @@protoc_insertion_point(field_mutable:message.Dispatch_data.response)
  return _internal_mutable_response();
}
inline void Dispatch_data::set_allocated_response(::message::Dispatch_response_msg* response) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(response_);
  }
  if (response) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(response)->GetArena();
    if (message_arena != submessage_arena) {
      response = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, response, submessage_arena);
    }
    _has_bits_[0] |= 0x00000004u;
  } else {
    _has_bits_[0] &= ~0x00000004u;
  }
  response_ = response;
  // @@protoc_insertion_point(field_set_allocated:message.Dispatch_data.response)
}

// optional string description = 3;
inline bool Dispatch_data::_internal_has_description() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Dispatch_data::has_description() const {
  return _internal_has_description();
}
inline void Dispatch_data::clear_description() {
  description_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Dispatch_data::description() const {
  // @@protoc_insertion_point(field_get:message.Dispatch_data.description)
  return _internal_description();
}
inline void Dispatch_data::set_description(const std::string& value) {
  _internal_set_description(value);
  // @@protoc_insertion_point(field_set:message.Dispatch_data.description)
}
inline std::string* Dispatch_data::mutable_description() {
  // @@protoc_insertion_point(field_mutable:message.Dispatch_data.description)
  return _internal_mutable_description();
}
inline const std::string& Dispatch_data::_internal_description() const {
  return description_.Get();
}
inline void Dispatch_data::_internal_set_description(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  description_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void Dispatch_data::set_description(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  description_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:message.Dispatch_data.description)
}
inline void Dispatch_data::set_description(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  description_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:message.Dispatch_data.description)
}
inline void Dispatch_data::set_description(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000001u;
  description_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:message.Dispatch_data.description)
}
inline std::string* Dispatch_data::_internal_mutable_description() {
  _has_bits_[0] |= 0x00000001u;
  return description_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* Dispatch_data::release_description() {
  // @@protoc_insertion_point(field_release:message.Dispatch_data.description)
  if (!_internal_has_description()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return description_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Dispatch_data::set_allocated_description(std::string* description) {
  if (description != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  description_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), description,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:message.Dispatch_data.description)
}

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

// Manual_operation_data

// required .message.Process_manual_operation_msg manual_operation = 1;
inline bool Manual_operation_data::_internal_has_manual_operation() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || manual_operation_ != nullptr);
  return value;
}
inline bool Manual_operation_data::has_manual_operation() const {
  return _internal_has_manual_operation();
}
inline const ::message::Process_manual_operation_msg& Manual_operation_data::_internal_manual_operation() const {
  const ::message::Process_manual_operation_msg* p = manual_operation_;
  return p != nullptr ? *p : *reinterpret_cast<const ::message::Process_manual_operation_msg*>(
      &::message::_Process_manual_operation_msg_default_instance_);
}
inline const ::message::Process_manual_operation_msg& Manual_operation_data::manual_operation() const {
  // @@protoc_insertion_point(field_get:message.Manual_operation_data.manual_operation)
  return _internal_manual_operation();
}
inline void Manual_operation_data::unsafe_arena_set_allocated_manual_operation(
    ::message::Process_manual_operation_msg* manual_operation) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(manual_operation_);
  }
  manual_operation_ = manual_operation;
  if (manual_operation) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:message.Manual_operation_data.manual_operation)
}
inline ::message::Process_manual_operation_msg* Manual_operation_data::release_manual_operation() {
  _has_bits_[0] &= ~0x00000002u;
  ::message::Process_manual_operation_msg* temp = manual_operation_;
  manual_operation_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::message::Process_manual_operation_msg* Manual_operation_data::unsafe_arena_release_manual_operation() {
  // @@protoc_insertion_point(field_release:message.Manual_operation_data.manual_operation)
  _has_bits_[0] &= ~0x00000002u;
  ::message::Process_manual_operation_msg* temp = manual_operation_;
  manual_operation_ = nullptr;
  return temp;
}
inline ::message::Process_manual_operation_msg* Manual_operation_data::_internal_mutable_manual_operation() {
  _has_bits_[0] |= 0x00000002u;
  if (manual_operation_ == nullptr) {
    auto* p = CreateMaybeMessage<::message::Process_manual_operation_msg>(GetArena());
    manual_operation_ = p;
  }
  return manual_operation_;
}
inline ::message::Process_manual_operation_msg* Manual_operation_data::mutable_manual_operation() {
  // @@protoc_insertion_point(field_mutable:message.Manual_operation_data.manual_operation)
  return _internal_mutable_manual_operation();
}
inline void Manual_operation_data::set_allocated_manual_operation(::message::Process_manual_operation_msg* manual_operation) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(manual_operation_);
  }
  if (manual_operation) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(manual_operation)->GetArena();
    if (message_arena != submessage_arena) {
      manual_operation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, manual_operation, submessage_arena);
    }
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  manual_operation_ = manual_operation;
  // @@protoc_insertion_point(field_set_allocated:message.Manual_operation_data.manual_operation)
}

// optional string description = 2;
inline bool Manual_operation_data::_internal_has_description() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Manual_operation_data::has_description() const {
  return _internal_has_description();
}
inline void Manual_operation_data::clear_description() {
  description_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Manual_operation_data::description() const {
  // @@protoc_insertion_point(field_get:message.Manual_operation_data.description)
  return _internal_description();
}
inline void Manual_operation_data::set_description(const std::string& value) {
  _internal_set_description(value);
  // @@protoc_insertion_point(field_set:message.Manual_operation_data.description)
}
inline std::string* Manual_operation_data::mutable_description() {
  // @@protoc_insertion_point(field_mutable:message.Manual_operation_data.description)
  return _internal_mutable_description();
}
inline const std::string& Manual_operation_data::_internal_description() const {
  return description_.Get();
}
inline void Manual_operation_data::_internal_set_description(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  description_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void Manual_operation_data::set_description(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  description_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:message.Manual_operation_data.description)
}
inline void Manual_operation_data::set_description(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  description_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:message.Manual_operation_data.description)
}
inline void Manual_operation_data::set_description(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000001u;
  description_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:message.Manual_operation_data.description)
}
inline std::string* Manual_operation_data::_internal_mutable_description() {
  _has_bits_[0] |= 0x00000001u;
  return description_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* Manual_operation_data::release_description() {
  // @@protoc_insertion_point(field_release:message.Manual_operation_data.description)
  if (!_internal_has_description()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return description_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Manual_operation_data::set_allocated_description(std::string* description) {
  if (description != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  description_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), description,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:message.Manual_operation_data.description)
}

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

// Log_data

// required .message.Log_data.Severity log_severity = 1;
inline bool Log_data::_internal_has_log_severity() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Log_data::has_log_severity() const {
  return _internal_has_log_severity();
}
inline void Log_data::clear_log_severity() {
  log_severity_ = 0;
  _has_bits_[0] &= ~0x00000001u;
}
inline ::message::Log_data_Severity Log_data::_internal_log_severity() const {
  return static_cast< ::message::Log_data_Severity >(log_severity_);
}
inline ::message::Log_data_Severity Log_data::log_severity() const {
  // @@protoc_insertion_point(field_get:message.Log_data.log_severity)
  return _internal_log_severity();
}
inline void Log_data::_internal_set_log_severity(::message::Log_data_Severity value) {
  assert(::message::Log_data_Severity_IsValid(value));
  _has_bits_[0] |= 0x00000001u;
  log_severity_ = value;
}
inline void Log_data::set_log_severity(::message::Log_data_Severity value) {
  _internal_set_log_severity(value);
  // @@protoc_insertion_point(field_set:message.Log_data.log_severity)
}

// string str_log = 2;
inline bool Log_data::_internal_has_str_log() const {
  return data_case() == kStrLog;
}
inline bool Log_data::has_str_log() const {
  return _internal_has_str_log();
}
inline void Log_data::set_has_str_log() {
  _oneof_case_[0] = kStrLog;
}
inline void Log_data::clear_str_log() {
  if (_internal_has_str_log()) {
    data_.str_log_.Destroy(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
    clear_has_data();
  }
}
inline const std::string& Log_data::str_log() const {
  // @@protoc_insertion_point(field_get:message.Log_data.str_log)
  return _internal_str_log();
}
inline void Log_data::set_str_log(const std::string& value) {
  _internal_set_str_log(value);
  // @@protoc_insertion_point(field_set:message.Log_data.str_log)
}
inline std::string* Log_data::mutable_str_log() {
  // @@protoc_insertion_point(field_mutable:message.Log_data.str_log)
  return _internal_mutable_str_log();
}
inline const std::string& Log_data::_internal_str_log() const {
  if (_internal_has_str_log()) {
    return data_.str_log_.Get();
  }
  return *&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
}
inline void Log_data::_internal_set_str_log(const std::string& value) {
  if (!_internal_has_str_log()) {
    clear_data();
    set_has_str_log();
    data_.str_log_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  data_.str_log_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void Log_data::set_str_log(std::string&& value) {
  // @@protoc_insertion_point(field_set:message.Log_data.str_log)
  if (!_internal_has_str_log()) {
    clear_data();
    set_has_str_log();
    data_.str_log_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  data_.str_log_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:message.Log_data.str_log)
}
inline void Log_data::set_str_log(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  if (!_internal_has_str_log()) {
    clear_data();
    set_has_str_log();
    data_.str_log_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  data_.str_log_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:message.Log_data.str_log)
}
inline void Log_data::set_str_log(const char* value,
                             size_t size) {
  if (!_internal_has_str_log()) {
    clear_data();
    set_has_str_log();
    data_.str_log_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  data_.str_log_.Set(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size),
      GetArena());
  // @@protoc_insertion_point(field_set_pointer:message.Log_data.str_log)
}
inline std::string* Log_data::_internal_mutable_str_log() {
  if (!_internal_has_str_log()) {
    clear_data();
    set_has_str_log();
    data_.str_log_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  return data_.str_log_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* Log_data::release_str_log() {
  // @@protoc_insertion_point(field_release:message.Log_data.str_log)
  if (_internal_has_str_log()) {
    clear_has_data();
    return data_.str_log_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  } else {
    return nullptr;
  }
}
inline void Log_data::set_allocated_str_log(std::string* str_log) {
  if (has_data()) {
    clear_data();
  }
  if (str_log != nullptr) {
    set_has_str_log();
    data_.str_log_.UnsafeSetDefault(str_log);
    ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena();
    if (arena != nullptr) {
      arena->Own(str_log);
    }
  }
  // @@protoc_insertion_point(field_set_allocated:message.Log_data.str_log)
}

// .message.Parkspace_data parkspace_log = 3;
inline bool Log_data::_internal_has_parkspace_log() const {
  return data_case() == kParkspaceLog;
}
inline bool Log_data::has_parkspace_log() const {
  return _internal_has_parkspace_log();
}
inline void Log_data::set_has_parkspace_log() {
  _oneof_case_[0] = kParkspaceLog;
}
inline void Log_data::clear_parkspace_log() {
  if (_internal_has_parkspace_log()) {
    if (GetArena() == nullptr) {
      delete data_.parkspace_log_;
    }
    clear_has_data();
  }
}
inline ::message::Parkspace_data* Log_data::release_parkspace_log() {
  // @@protoc_insertion_point(field_release:message.Log_data.parkspace_log)
  if (_internal_has_parkspace_log()) {
    clear_has_data();
      ::message::Parkspace_data* temp = data_.parkspace_log_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    data_.parkspace_log_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::message::Parkspace_data& Log_data::_internal_parkspace_log() const {
  return _internal_has_parkspace_log()
      ? *data_.parkspace_log_
      : *reinterpret_cast< ::message::Parkspace_data*>(&::message::_Parkspace_data_default_instance_);
}
inline const ::message::Parkspace_data& Log_data::parkspace_log() const {
  // @@protoc_insertion_point(field_get:message.Log_data.parkspace_log)
  return _internal_parkspace_log();
}
inline ::message::Parkspace_data* Log_data::unsafe_arena_release_parkspace_log() {
  // @@protoc_insertion_point(field_unsafe_arena_release:message.Log_data.parkspace_log)
  if (_internal_has_parkspace_log()) {
    clear_has_data();
    ::message::Parkspace_data* temp = data_.parkspace_log_;
    data_.parkspace_log_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Log_data::unsafe_arena_set_allocated_parkspace_log(::message::Parkspace_data* parkspace_log) {
  clear_data();
  if (parkspace_log) {
    set_has_parkspace_log();
    data_.parkspace_log_ = parkspace_log;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:message.Log_data.parkspace_log)
}
inline ::message::Parkspace_data* Log_data::_internal_mutable_parkspace_log() {
  if (!_internal_has_parkspace_log()) {
    clear_data();
    set_has_parkspace_log();
    data_.parkspace_log_ = CreateMaybeMessage< ::message::Parkspace_data >(GetArena());
  }
  return data_.parkspace_log_;
}
inline ::message::Parkspace_data* Log_data::mutable_parkspace_log() {
  // @@protoc_insertion_point(field_mutable:message.Log_data.parkspace_log)
  return _internal_mutable_parkspace_log();
}

// .message.Measure_data measure_log = 4;
inline bool Log_data::_internal_has_measure_log() const {
  return data_case() == kMeasureLog;
}
inline bool Log_data::has_measure_log() const {
  return _internal_has_measure_log();
}
inline void Log_data::set_has_measure_log() {
  _oneof_case_[0] = kMeasureLog;
}
inline void Log_data::clear_measure_log() {
  if (_internal_has_measure_log()) {
    if (GetArena() == nullptr) {
      delete data_.measure_log_;
    }
    clear_has_data();
  }
}
inline ::message::Measure_data* Log_data::release_measure_log() {
  // @@protoc_insertion_point(field_release:message.Log_data.measure_log)
  if (_internal_has_measure_log()) {
    clear_has_data();
      ::message::Measure_data* temp = data_.measure_log_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    data_.measure_log_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::message::Measure_data& Log_data::_internal_measure_log() const {
  return _internal_has_measure_log()
      ? *data_.measure_log_
      : *reinterpret_cast< ::message::Measure_data*>(&::message::_Measure_data_default_instance_);
}
inline const ::message::Measure_data& Log_data::measure_log() const {
  // @@protoc_insertion_point(field_get:message.Log_data.measure_log)
  return _internal_measure_log();
}
inline ::message::Measure_data* Log_data::unsafe_arena_release_measure_log() {
  // @@protoc_insertion_point(field_unsafe_arena_release:message.Log_data.measure_log)
  if (_internal_has_measure_log()) {
    clear_has_data();
    ::message::Measure_data* temp = data_.measure_log_;
    data_.measure_log_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Log_data::unsafe_arena_set_allocated_measure_log(::message::Measure_data* measure_log) {
  clear_data();
  if (measure_log) {
    set_has_measure_log();
    data_.measure_log_ = measure_log;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:message.Log_data.measure_log)
}
inline ::message::Measure_data* Log_data::_internal_mutable_measure_log() {
  if (!_internal_has_measure_log()) {
    clear_data();
    set_has_measure_log();
    data_.measure_log_ = CreateMaybeMessage< ::message::Measure_data >(GetArena());
  }
  return data_.measure_log_;
}
inline ::message::Measure_data* Log_data::mutable_measure_log() {
  // @@protoc_insertion_point(field_mutable:message.Log_data.measure_log)
  return _internal_mutable_measure_log();
}

// .message.Dispatch_data dispatch_log = 5;
inline bool Log_data::_internal_has_dispatch_log() const {
  return data_case() == kDispatchLog;
}
inline bool Log_data::has_dispatch_log() const {
  return _internal_has_dispatch_log();
}
inline void Log_data::set_has_dispatch_log() {
  _oneof_case_[0] = kDispatchLog;
}
inline void Log_data::clear_dispatch_log() {
  if (_internal_has_dispatch_log()) {
    if (GetArena() == nullptr) {
      delete data_.dispatch_log_;
    }
    clear_has_data();
  }
}
inline ::message::Dispatch_data* Log_data::release_dispatch_log() {
  // @@protoc_insertion_point(field_release:message.Log_data.dispatch_log)
  if (_internal_has_dispatch_log()) {
    clear_has_data();
      ::message::Dispatch_data* temp = data_.dispatch_log_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    data_.dispatch_log_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::message::Dispatch_data& Log_data::_internal_dispatch_log() const {
  return _internal_has_dispatch_log()
      ? *data_.dispatch_log_
      : *reinterpret_cast< ::message::Dispatch_data*>(&::message::_Dispatch_data_default_instance_);
}
inline const ::message::Dispatch_data& Log_data::dispatch_log() const {
  // @@protoc_insertion_point(field_get:message.Log_data.dispatch_log)
  return _internal_dispatch_log();
}
inline ::message::Dispatch_data* Log_data::unsafe_arena_release_dispatch_log() {
  // @@protoc_insertion_point(field_unsafe_arena_release:message.Log_data.dispatch_log)
  if (_internal_has_dispatch_log()) {
    clear_has_data();
    ::message::Dispatch_data* temp = data_.dispatch_log_;
    data_.dispatch_log_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Log_data::unsafe_arena_set_allocated_dispatch_log(::message::Dispatch_data* dispatch_log) {
  clear_data();
  if (dispatch_log) {
    set_has_dispatch_log();
    data_.dispatch_log_ = dispatch_log;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:message.Log_data.dispatch_log)
}
inline ::message::Dispatch_data* Log_data::_internal_mutable_dispatch_log() {
  if (!_internal_has_dispatch_log()) {
    clear_data();
    set_has_dispatch_log();
    data_.dispatch_log_ = CreateMaybeMessage< ::message::Dispatch_data >(GetArena());
  }
  return data_.dispatch_log_;
}
inline ::message::Dispatch_data* Log_data::mutable_dispatch_log() {
  // @@protoc_insertion_point(field_mutable:message.Log_data.dispatch_log)
  return _internal_mutable_dispatch_log();
}

// .message.Manual_operation_data manual_operator_log = 6;
inline bool Log_data::_internal_has_manual_operator_log() const {
  return data_case() == kManualOperatorLog;
}
inline bool Log_data::has_manual_operator_log() const {
  return _internal_has_manual_operator_log();
}
inline void Log_data::set_has_manual_operator_log() {
  _oneof_case_[0] = kManualOperatorLog;
}
inline void Log_data::clear_manual_operator_log() {
  if (_internal_has_manual_operator_log()) {
    if (GetArena() == nullptr) {
      delete data_.manual_operator_log_;
    }
    clear_has_data();
  }
}
inline ::message::Manual_operation_data* Log_data::release_manual_operator_log() {
  // @@protoc_insertion_point(field_release:message.Log_data.manual_operator_log)
  if (_internal_has_manual_operator_log()) {
    clear_has_data();
      ::message::Manual_operation_data* temp = data_.manual_operator_log_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    data_.manual_operator_log_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::message::Manual_operation_data& Log_data::_internal_manual_operator_log() const {
  return _internal_has_manual_operator_log()
      ? *data_.manual_operator_log_
      : *reinterpret_cast< ::message::Manual_operation_data*>(&::message::_Manual_operation_data_default_instance_);
}
inline const ::message::Manual_operation_data& Log_data::manual_operator_log() const {
  // @@protoc_insertion_point(field_get:message.Log_data.manual_operator_log)
  return _internal_manual_operator_log();
}
inline ::message::Manual_operation_data* Log_data::unsafe_arena_release_manual_operator_log() {
  // @@protoc_insertion_point(field_unsafe_arena_release:message.Log_data.manual_operator_log)
  if (_internal_has_manual_operator_log()) {
    clear_has_data();
    ::message::Manual_operation_data* temp = data_.manual_operator_log_;
    data_.manual_operator_log_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Log_data::unsafe_arena_set_allocated_manual_operator_log(::message::Manual_operation_data* manual_operator_log) {
  clear_data();
  if (manual_operator_log) {
    set_has_manual_operator_log();
    data_.manual_operator_log_ = manual_operator_log;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:message.Log_data.manual_operator_log)
}
inline ::message::Manual_operation_data* Log_data::_internal_mutable_manual_operator_log() {
  if (!_internal_has_manual_operator_log()) {
    clear_data();
    set_has_manual_operator_log();
    data_.manual_operator_log_ = CreateMaybeMessage< ::message::Manual_operation_data >(GetArena());
  }
  return data_.manual_operator_log_;
}
inline ::message::Manual_operation_data* Log_data::mutable_manual_operator_log() {
  // @@protoc_insertion_point(field_mutable:message.Log_data.manual_operator_log)
  return _internal_mutable_manual_operator_log();
}

inline bool Log_data::has_data() const {
  return data_case() != DATA_NOT_SET;
}
inline void Log_data::clear_has_data() {
  _oneof_case_[0] = DATA_NOT_SET;
}
inline Log_data::DataCase Log_data::data_case() const {
  return Log_data::DataCase(_oneof_case_[0]);
}
// -------------------------------------------------------------------

// Process_log

// required .message.Process_type process_type = 1;
inline bool Process_log::_internal_has_process_type() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Process_log::has_process_type() const {
  return _internal_has_process_type();
}
inline void Process_log::clear_process_type() {
  process_type_ = 1;
  _has_bits_[0] &= ~0x00000001u;
}
inline ::message::Process_type Process_log::_internal_process_type() const {
  return static_cast< ::message::Process_type >(process_type_);
}
inline ::message::Process_type Process_log::process_type() const {
  // @@protoc_insertion_point(field_get:message.Process_log.process_type)
  return _internal_process_type();
}
inline void Process_log::_internal_set_process_type(::message::Process_type value) {
  assert(::message::Process_type_IsValid(value));
  _has_bits_[0] |= 0x00000001u;
  process_type_ = value;
}
inline void Process_log::set_process_type(::message::Process_type value) {
  _internal_set_process_type(value);
  // @@protoc_insertion_point(field_set:message.Process_log.process_type)
}

// repeated .message.Log_data log_data = 2;
inline int Process_log::_internal_log_data_size() const {
  return log_data_.size();
}
inline int Process_log::log_data_size() const {
  return _internal_log_data_size();
}
inline void Process_log::clear_log_data() {
  log_data_.Clear();
}
inline ::message::Log_data* Process_log::mutable_log_data(int index) {
  // @@protoc_insertion_point(field_mutable:message.Process_log.log_data)
  return log_data_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::message::Log_data >*
Process_log::mutable_log_data() {
  // @@protoc_insertion_point(field_mutable_list:message.Process_log.log_data)
  return &log_data_;
}
inline const ::message::Log_data& Process_log::_internal_log_data(int index) const {
  return log_data_.Get(index);
}
inline const ::message::Log_data& Process_log::log_data(int index) const {
  // @@protoc_insertion_point(field_get:message.Process_log.log_data)
  return _internal_log_data(index);
}
inline ::message::Log_data* Process_log::_internal_add_log_data() {
  return log_data_.Add();
}
inline ::message::Log_data* Process_log::add_log_data() {
  // @@protoc_insertion_point(field_add:message.Process_log.log_data)
  return _internal_add_log_data();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::message::Log_data >&
Process_log::log_data() const {
  // @@protoc_insertion_point(field_list:message.Process_log.log_data)
  return log_data_;
}

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

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

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

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

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace message

PROTOBUF_NAMESPACE_OPEN

template <> struct is_proto_enum< ::message::Log_data_Severity> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::message::Log_data_Severity>() {
  return ::message::Log_data_Severity_descriptor();
}

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

#include <google/protobuf/port_undef.inc>
#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_log_5fprocess_2eproto