// 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 < 4000000
#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 4000000 < 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[4]
    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 Log_data;
class Log_dataDefaultTypeInternal;
extern Log_dataDefaultTypeInternal _Log_data_default_instance_;
class Manual_operation_log;
class Manual_operation_logDefaultTypeInternal;
extern Manual_operation_logDefaultTypeInternal _Manual_operation_log_default_instance_;
class Node_log;
class Node_logDefaultTypeInternal;
extern Node_logDefaultTypeInternal _Node_log_default_instance_;
class Process_log;
class Process_logDefaultTypeInternal;
extern Process_logDefaultTypeInternal _Process_log_default_instance_;
}  // namespace message
PROTOBUF_NAMESPACE_OPEN
template<> ::message::Log_data* Arena::CreateMaybeMessage<::message::Log_data>(Arena*);
template<> ::message::Manual_operation_log* Arena::CreateMaybeMessage<::message::Manual_operation_log>(Arena*);
template<> ::message::Node_log* Arena::CreateMaybeMessage<::message::Node_log>(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 Node_log PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:message.Node_log) */ {
 public:
  inline Node_log() : Node_log(nullptr) {}
  virtual ~Node_log();

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

  inline Node_log& operator=(const Node_log& from) {
    CopyFrom(from);
    return *this;
  }
  inline Node_log& operator=(Node_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 Node_log& default_instance();

  enum RequestCase {
    kAllocRequest = 1,
    kSearchRequest = 3,
    kReleaseRequest = 5,
    kConfirmRequest = 7,
    kMeasureRequest = 9,
    kDispatchRequest = 11,
    REQUEST_NOT_SET = 0,
  };

  enum ResponseCase {
    kAllocResponse = 2,
    kSearchResponse = 4,
    kReleaseResponse = 6,
    kConfirmResponse = 8,
    kMeasureResponse = 10,
    kDispatchResponse = 12,
    RESPONSE_NOT_SET = 0,
  };

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

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

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

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

  Node_log* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<Node_log>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const Node_log& from);
  void MergeFrom(const Node_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(Node_log* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "message.Node_log";
  }
  protected:
  explicit Node_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 {
    kDescriptionFieldNumber = 13,
    kAllocRequestFieldNumber = 1,
    kSearchRequestFieldNumber = 3,
    kReleaseRequestFieldNumber = 5,
    kConfirmRequestFieldNumber = 7,
    kMeasureRequestFieldNumber = 9,
    kDispatchRequestFieldNumber = 11,
    kAllocResponseFieldNumber = 2,
    kSearchResponseFieldNumber = 4,
    kReleaseResponseFieldNumber = 6,
    kConfirmResponseFieldNumber = 8,
    kMeasureResponseFieldNumber = 10,
    kDispatchResponseFieldNumber = 12,
  };
  // optional string description = 13;
  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:

  // .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();

  // .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();

  // .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();

  // .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();

  // .message.Measure_request_msg measure_request = 9;
  bool has_measure_request() const;
  private:
  bool _internal_has_measure_request() const;
  public:
  void clear_measure_request();
  const ::message::Measure_request_msg& measure_request() const;
  ::message::Measure_request_msg* release_measure_request();
  ::message::Measure_request_msg* mutable_measure_request();
  void set_allocated_measure_request(::message::Measure_request_msg* measure_request);
  private:
  const ::message::Measure_request_msg& _internal_measure_request() const;
  ::message::Measure_request_msg* _internal_mutable_measure_request();
  public:
  void unsafe_arena_set_allocated_measure_request(
      ::message::Measure_request_msg* measure_request);
  ::message::Measure_request_msg* unsafe_arena_release_measure_request();

  // .message.Dispatch_request_msg dispatch_request = 11;
  bool has_dispatch_request() const;
  private:
  bool _internal_has_dispatch_request() const;
  public:
  void clear_dispatch_request();
  const ::message::Dispatch_request_msg& dispatch_request() const;
  ::message::Dispatch_request_msg* release_dispatch_request();
  ::message::Dispatch_request_msg* mutable_dispatch_request();
  void set_allocated_dispatch_request(::message::Dispatch_request_msg* dispatch_request);
  private:
  const ::message::Dispatch_request_msg& _internal_dispatch_request() const;
  ::message::Dispatch_request_msg* _internal_mutable_dispatch_request();
  public:
  void unsafe_arena_set_allocated_dispatch_request(
      ::message::Dispatch_request_msg* dispatch_request);
  ::message::Dispatch_request_msg* unsafe_arena_release_dispatch_request();

  // .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();

  // .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();

  // .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();

  // .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();

  // .message.Measure_response_msg measure_response = 10;
  bool has_measure_response() const;
  private:
  bool _internal_has_measure_response() const;
  public:
  void clear_measure_response();
  const ::message::Measure_response_msg& measure_response() const;
  ::message::Measure_response_msg* release_measure_response();
  ::message::Measure_response_msg* mutable_measure_response();
  void set_allocated_measure_response(::message::Measure_response_msg* measure_response);
  private:
  const ::message::Measure_response_msg& _internal_measure_response() const;
  ::message::Measure_response_msg* _internal_mutable_measure_response();
  public:
  void unsafe_arena_set_allocated_measure_response(
      ::message::Measure_response_msg* measure_response);
  ::message::Measure_response_msg* unsafe_arena_release_measure_response();

  // .message.Dispatch_response_msg dispatch_response = 12;
  bool has_dispatch_response() const;
  private:
  bool _internal_has_dispatch_response() const;
  public:
  void clear_dispatch_response();
  const ::message::Dispatch_response_msg& dispatch_response() const;
  ::message::Dispatch_response_msg* release_dispatch_response();
  ::message::Dispatch_response_msg* mutable_dispatch_response();
  void set_allocated_dispatch_response(::message::Dispatch_response_msg* dispatch_response);
  private:
  const ::message::Dispatch_response_msg& _internal_dispatch_response() const;
  ::message::Dispatch_response_msg* _internal_mutable_dispatch_response();
  public:
  void unsafe_arena_set_allocated_dispatch_response(
      ::message::Dispatch_response_msg* dispatch_response);
  ::message::Dispatch_response_msg* unsafe_arena_release_dispatch_response();

  void clear_request();
  RequestCase request_case() const;
  void clear_response();
  ResponseCase response_case() const;
  // @@protoc_insertion_point(class_scope:message.Node_log)
 private:
  class _Internal;
  void set_has_alloc_request();
  void set_has_search_request();
  void set_has_release_request();
  void set_has_confirm_request();
  void set_has_measure_request();
  void set_has_dispatch_request();
  void set_has_alloc_response();
  void set_has_search_response();
  void set_has_release_response();
  void set_has_confirm_response();
  void set_has_measure_response();
  void set_has_dispatch_response();

  inline bool has_request() const;
  inline void clear_has_request();

  inline bool has_response() const;
  inline void clear_has_response();

  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_;
  union RequestUnion {
    RequestUnion() {}
    ::message::Parkspace_allocation_request_msg* alloc_request_;
    ::message::Parkspace_search_request_msg* search_request_;
    ::message::Parkspace_release_request_msg* release_request_;
    ::message::Parkspace_confirm_alloc_request_msg* confirm_request_;
    ::message::Measure_request_msg* measure_request_;
    ::message::Dispatch_request_msg* dispatch_request_;
  } request_;
  union ResponseUnion {
    ResponseUnion() {}
    ::message::Parkspace_allocation_response_msg* alloc_response_;
    ::message::Parkspace_search_response_msg* search_response_;
    ::message::Parkspace_release_response_msg* release_response_;
    ::message::Parkspace_confirm_alloc_response_msg* confirm_response_;
    ::message::Measure_response_msg* measure_response_;
    ::message::Dispatch_response_msg* dispatch_response_;
  } response_;
  ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[2];

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

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

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

  inline Manual_operation_log& operator=(const Manual_operation_log& from) {
    CopyFrom(from);
    return *this;
  }
  inline Manual_operation_log& operator=(Manual_operation_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 Manual_operation_log& default_instance();

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

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

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

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

  Manual_operation_log* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<Manual_operation_log>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const Manual_operation_log& from);
  void MergeFrom(const Manual_operation_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(Manual_operation_log* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "message.Manual_operation_log";
  }
  protected:
  explicit Manual_operation_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 {
    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_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::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,
    kNodeLog = 3,
    kManualOperatorLog = 4,
    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 =
    2;

  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,
    kNodeLogFieldNumber = 3,
    kManualOperatorLogFieldNumber = 4,
  };
  // 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.Node_log node_log = 3;
  bool has_node_log() const;
  private:
  bool _internal_has_node_log() const;
  public:
  void clear_node_log();
  const ::message::Node_log& node_log() const;
  ::message::Node_log* release_node_log();
  ::message::Node_log* mutable_node_log();
  void set_allocated_node_log(::message::Node_log* node_log);
  private:
  const ::message::Node_log& _internal_node_log() const;
  ::message::Node_log* _internal_mutable_node_log();
  public:
  void unsafe_arena_set_allocated_node_log(
      ::message::Node_log* node_log);
  ::message::Node_log* unsafe_arena_release_node_log();

  // .message.Manual_operation_log manual_operator_log = 4;
  bool has_manual_operator_log() const;
  private:
  bool _internal_has_manual_operator_log() const;
  public:
  void clear_manual_operator_log();
  const ::message::Manual_operation_log& manual_operator_log() const;
  ::message::Manual_operation_log* release_manual_operator_log();
  ::message::Manual_operation_log* mutable_manual_operator_log();
  void set_allocated_manual_operator_log(::message::Manual_operation_log* manual_operator_log);
  private:
  const ::message::Manual_operation_log& _internal_manual_operator_log() const;
  ::message::Manual_operation_log* _internal_mutable_manual_operator_log();
  public:
  void unsafe_arena_set_allocated_manual_operator_log(
      ::message::Manual_operation_log* manual_operator_log);
  ::message::Manual_operation_log* 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_node_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::Node_log* node_log_;
    ::message::Manual_operation_log* 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 =
    3;

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

// .message.Parkspace_allocation_request_msg alloc_request = 1;
inline bool Node_log::_internal_has_alloc_request() const {
  return request_case() == kAllocRequest;
}
inline bool Node_log::has_alloc_request() const {
  return _internal_has_alloc_request();
}
inline void Node_log::set_has_alloc_request() {
  _oneof_case_[0] = kAllocRequest;
}
inline ::message::Parkspace_allocation_request_msg* Node_log::release_alloc_request() {
  // @@protoc_insertion_point(field_release:message.Node_log.alloc_request)
  if (_internal_has_alloc_request()) {
    clear_has_request();
      ::message::Parkspace_allocation_request_msg* temp = request_.alloc_request_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    request_.alloc_request_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::message::Parkspace_allocation_request_msg& Node_log::_internal_alloc_request() const {
  return _internal_has_alloc_request()
      ? *request_.alloc_request_
      : *reinterpret_cast< ::message::Parkspace_allocation_request_msg*>(&::message::_Parkspace_allocation_request_msg_default_instance_);
}
inline const ::message::Parkspace_allocation_request_msg& Node_log::alloc_request() const {
  // @@protoc_insertion_point(field_get:message.Node_log.alloc_request)
  return _internal_alloc_request();
}
inline ::message::Parkspace_allocation_request_msg* Node_log::unsafe_arena_release_alloc_request() {
  // @@protoc_insertion_point(field_unsafe_arena_release:message.Node_log.alloc_request)
  if (_internal_has_alloc_request()) {
    clear_has_request();
    ::message::Parkspace_allocation_request_msg* temp = request_.alloc_request_;
    request_.alloc_request_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node_log::unsafe_arena_set_allocated_alloc_request(::message::Parkspace_allocation_request_msg* alloc_request) {
  clear_request();
  if (alloc_request) {
    set_has_alloc_request();
    request_.alloc_request_ = alloc_request;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:message.Node_log.alloc_request)
}
inline ::message::Parkspace_allocation_request_msg* Node_log::_internal_mutable_alloc_request() {
  if (!_internal_has_alloc_request()) {
    clear_request();
    set_has_alloc_request();
    request_.alloc_request_ = CreateMaybeMessage< ::message::Parkspace_allocation_request_msg >(GetArena());
  }
  return request_.alloc_request_;
}
inline ::message::Parkspace_allocation_request_msg* Node_log::mutable_alloc_request() {
  // @@protoc_insertion_point(field_mutable:message.Node_log.alloc_request)
  return _internal_mutable_alloc_request();
}

// .message.Parkspace_search_request_msg search_request = 3;
inline bool Node_log::_internal_has_search_request() const {
  return request_case() == kSearchRequest;
}
inline bool Node_log::has_search_request() const {
  return _internal_has_search_request();
}
inline void Node_log::set_has_search_request() {
  _oneof_case_[0] = kSearchRequest;
}
inline ::message::Parkspace_search_request_msg* Node_log::release_search_request() {
  // @@protoc_insertion_point(field_release:message.Node_log.search_request)
  if (_internal_has_search_request()) {
    clear_has_request();
      ::message::Parkspace_search_request_msg* temp = request_.search_request_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    request_.search_request_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::message::Parkspace_search_request_msg& Node_log::_internal_search_request() const {
  return _internal_has_search_request()
      ? *request_.search_request_
      : *reinterpret_cast< ::message::Parkspace_search_request_msg*>(&::message::_Parkspace_search_request_msg_default_instance_);
}
inline const ::message::Parkspace_search_request_msg& Node_log::search_request() const {
  // @@protoc_insertion_point(field_get:message.Node_log.search_request)
  return _internal_search_request();
}
inline ::message::Parkspace_search_request_msg* Node_log::unsafe_arena_release_search_request() {
  // @@protoc_insertion_point(field_unsafe_arena_release:message.Node_log.search_request)
  if (_internal_has_search_request()) {
    clear_has_request();
    ::message::Parkspace_search_request_msg* temp = request_.search_request_;
    request_.search_request_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node_log::unsafe_arena_set_allocated_search_request(::message::Parkspace_search_request_msg* search_request) {
  clear_request();
  if (search_request) {
    set_has_search_request();
    request_.search_request_ = search_request;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:message.Node_log.search_request)
}
inline ::message::Parkspace_search_request_msg* Node_log::_internal_mutable_search_request() {
  if (!_internal_has_search_request()) {
    clear_request();
    set_has_search_request();
    request_.search_request_ = CreateMaybeMessage< ::message::Parkspace_search_request_msg >(GetArena());
  }
  return request_.search_request_;
}
inline ::message::Parkspace_search_request_msg* Node_log::mutable_search_request() {
  // @@protoc_insertion_point(field_mutable:message.Node_log.search_request)
  return _internal_mutable_search_request();
}

// .message.Parkspace_release_request_msg release_request = 5;
inline bool Node_log::_internal_has_release_request() const {
  return request_case() == kReleaseRequest;
}
inline bool Node_log::has_release_request() const {
  return _internal_has_release_request();
}
inline void Node_log::set_has_release_request() {
  _oneof_case_[0] = kReleaseRequest;
}
inline ::message::Parkspace_release_request_msg* Node_log::release_release_request() {
  // @@protoc_insertion_point(field_release:message.Node_log.release_request)
  if (_internal_has_release_request()) {
    clear_has_request();
      ::message::Parkspace_release_request_msg* temp = request_.release_request_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    request_.release_request_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::message::Parkspace_release_request_msg& Node_log::_internal_release_request() const {
  return _internal_has_release_request()
      ? *request_.release_request_
      : *reinterpret_cast< ::message::Parkspace_release_request_msg*>(&::message::_Parkspace_release_request_msg_default_instance_);
}
inline const ::message::Parkspace_release_request_msg& Node_log::release_request() const {
  // @@protoc_insertion_point(field_get:message.Node_log.release_request)
  return _internal_release_request();
}
inline ::message::Parkspace_release_request_msg* Node_log::unsafe_arena_release_release_request() {
  // @@protoc_insertion_point(field_unsafe_arena_release:message.Node_log.release_request)
  if (_internal_has_release_request()) {
    clear_has_request();
    ::message::Parkspace_release_request_msg* temp = request_.release_request_;
    request_.release_request_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node_log::unsafe_arena_set_allocated_release_request(::message::Parkspace_release_request_msg* release_request) {
  clear_request();
  if (release_request) {
    set_has_release_request();
    request_.release_request_ = release_request;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:message.Node_log.release_request)
}
inline ::message::Parkspace_release_request_msg* Node_log::_internal_mutable_release_request() {
  if (!_internal_has_release_request()) {
    clear_request();
    set_has_release_request();
    request_.release_request_ = CreateMaybeMessage< ::message::Parkspace_release_request_msg >(GetArena());
  }
  return request_.release_request_;
}
inline ::message::Parkspace_release_request_msg* Node_log::mutable_release_request() {
  // @@protoc_insertion_point(field_mutable:message.Node_log.release_request)
  return _internal_mutable_release_request();
}

// .message.Parkspace_confirm_alloc_request_msg confirm_request = 7;
inline bool Node_log::_internal_has_confirm_request() const {
  return request_case() == kConfirmRequest;
}
inline bool Node_log::has_confirm_request() const {
  return _internal_has_confirm_request();
}
inline void Node_log::set_has_confirm_request() {
  _oneof_case_[0] = kConfirmRequest;
}
inline ::message::Parkspace_confirm_alloc_request_msg* Node_log::release_confirm_request() {
  // @@protoc_insertion_point(field_release:message.Node_log.confirm_request)
  if (_internal_has_confirm_request()) {
    clear_has_request();
      ::message::Parkspace_confirm_alloc_request_msg* temp = request_.confirm_request_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    request_.confirm_request_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::message::Parkspace_confirm_alloc_request_msg& Node_log::_internal_confirm_request() const {
  return _internal_has_confirm_request()
      ? *request_.confirm_request_
      : *reinterpret_cast< ::message::Parkspace_confirm_alloc_request_msg*>(&::message::_Parkspace_confirm_alloc_request_msg_default_instance_);
}
inline const ::message::Parkspace_confirm_alloc_request_msg& Node_log::confirm_request() const {
  // @@protoc_insertion_point(field_get:message.Node_log.confirm_request)
  return _internal_confirm_request();
}
inline ::message::Parkspace_confirm_alloc_request_msg* Node_log::unsafe_arena_release_confirm_request() {
  // @@protoc_insertion_point(field_unsafe_arena_release:message.Node_log.confirm_request)
  if (_internal_has_confirm_request()) {
    clear_has_request();
    ::message::Parkspace_confirm_alloc_request_msg* temp = request_.confirm_request_;
    request_.confirm_request_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node_log::unsafe_arena_set_allocated_confirm_request(::message::Parkspace_confirm_alloc_request_msg* confirm_request) {
  clear_request();
  if (confirm_request) {
    set_has_confirm_request();
    request_.confirm_request_ = confirm_request;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:message.Node_log.confirm_request)
}
inline ::message::Parkspace_confirm_alloc_request_msg* Node_log::_internal_mutable_confirm_request() {
  if (!_internal_has_confirm_request()) {
    clear_request();
    set_has_confirm_request();
    request_.confirm_request_ = CreateMaybeMessage< ::message::Parkspace_confirm_alloc_request_msg >(GetArena());
  }
  return request_.confirm_request_;
}
inline ::message::Parkspace_confirm_alloc_request_msg* Node_log::mutable_confirm_request() {
  // @@protoc_insertion_point(field_mutable:message.Node_log.confirm_request)
  return _internal_mutable_confirm_request();
}

// .message.Measure_request_msg measure_request = 9;
inline bool Node_log::_internal_has_measure_request() const {
  return request_case() == kMeasureRequest;
}
inline bool Node_log::has_measure_request() const {
  return _internal_has_measure_request();
}
inline void Node_log::set_has_measure_request() {
  _oneof_case_[0] = kMeasureRequest;
}
inline ::message::Measure_request_msg* Node_log::release_measure_request() {
  // @@protoc_insertion_point(field_release:message.Node_log.measure_request)
  if (_internal_has_measure_request()) {
    clear_has_request();
      ::message::Measure_request_msg* temp = request_.measure_request_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    request_.measure_request_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::message::Measure_request_msg& Node_log::_internal_measure_request() const {
  return _internal_has_measure_request()
      ? *request_.measure_request_
      : *reinterpret_cast< ::message::Measure_request_msg*>(&::message::_Measure_request_msg_default_instance_);
}
inline const ::message::Measure_request_msg& Node_log::measure_request() const {
  // @@protoc_insertion_point(field_get:message.Node_log.measure_request)
  return _internal_measure_request();
}
inline ::message::Measure_request_msg* Node_log::unsafe_arena_release_measure_request() {
  // @@protoc_insertion_point(field_unsafe_arena_release:message.Node_log.measure_request)
  if (_internal_has_measure_request()) {
    clear_has_request();
    ::message::Measure_request_msg* temp = request_.measure_request_;
    request_.measure_request_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node_log::unsafe_arena_set_allocated_measure_request(::message::Measure_request_msg* measure_request) {
  clear_request();
  if (measure_request) {
    set_has_measure_request();
    request_.measure_request_ = measure_request;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:message.Node_log.measure_request)
}
inline ::message::Measure_request_msg* Node_log::_internal_mutable_measure_request() {
  if (!_internal_has_measure_request()) {
    clear_request();
    set_has_measure_request();
    request_.measure_request_ = CreateMaybeMessage< ::message::Measure_request_msg >(GetArena());
  }
  return request_.measure_request_;
}
inline ::message::Measure_request_msg* Node_log::mutable_measure_request() {
  // @@protoc_insertion_point(field_mutable:message.Node_log.measure_request)
  return _internal_mutable_measure_request();
}

// .message.Dispatch_request_msg dispatch_request = 11;
inline bool Node_log::_internal_has_dispatch_request() const {
  return request_case() == kDispatchRequest;
}
inline bool Node_log::has_dispatch_request() const {
  return _internal_has_dispatch_request();
}
inline void Node_log::set_has_dispatch_request() {
  _oneof_case_[0] = kDispatchRequest;
}
inline ::message::Dispatch_request_msg* Node_log::release_dispatch_request() {
  // @@protoc_insertion_point(field_release:message.Node_log.dispatch_request)
  if (_internal_has_dispatch_request()) {
    clear_has_request();
      ::message::Dispatch_request_msg* temp = request_.dispatch_request_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    request_.dispatch_request_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::message::Dispatch_request_msg& Node_log::_internal_dispatch_request() const {
  return _internal_has_dispatch_request()
      ? *request_.dispatch_request_
      : *reinterpret_cast< ::message::Dispatch_request_msg*>(&::message::_Dispatch_request_msg_default_instance_);
}
inline const ::message::Dispatch_request_msg& Node_log::dispatch_request() const {
  // @@protoc_insertion_point(field_get:message.Node_log.dispatch_request)
  return _internal_dispatch_request();
}
inline ::message::Dispatch_request_msg* Node_log::unsafe_arena_release_dispatch_request() {
  // @@protoc_insertion_point(field_unsafe_arena_release:message.Node_log.dispatch_request)
  if (_internal_has_dispatch_request()) {
    clear_has_request();
    ::message::Dispatch_request_msg* temp = request_.dispatch_request_;
    request_.dispatch_request_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node_log::unsafe_arena_set_allocated_dispatch_request(::message::Dispatch_request_msg* dispatch_request) {
  clear_request();
  if (dispatch_request) {
    set_has_dispatch_request();
    request_.dispatch_request_ = dispatch_request;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:message.Node_log.dispatch_request)
}
inline ::message::Dispatch_request_msg* Node_log::_internal_mutable_dispatch_request() {
  if (!_internal_has_dispatch_request()) {
    clear_request();
    set_has_dispatch_request();
    request_.dispatch_request_ = CreateMaybeMessage< ::message::Dispatch_request_msg >(GetArena());
  }
  return request_.dispatch_request_;
}
inline ::message::Dispatch_request_msg* Node_log::mutable_dispatch_request() {
  // @@protoc_insertion_point(field_mutable:message.Node_log.dispatch_request)
  return _internal_mutable_dispatch_request();
}

// .message.Parkspace_allocation_response_msg alloc_response = 2;
inline bool Node_log::_internal_has_alloc_response() const {
  return response_case() == kAllocResponse;
}
inline bool Node_log::has_alloc_response() const {
  return _internal_has_alloc_response();
}
inline void Node_log::set_has_alloc_response() {
  _oneof_case_[1] = kAllocResponse;
}
inline ::message::Parkspace_allocation_response_msg* Node_log::release_alloc_response() {
  // @@protoc_insertion_point(field_release:message.Node_log.alloc_response)
  if (_internal_has_alloc_response()) {
    clear_has_response();
      ::message::Parkspace_allocation_response_msg* temp = response_.alloc_response_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    response_.alloc_response_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::message::Parkspace_allocation_response_msg& Node_log::_internal_alloc_response() const {
  return _internal_has_alloc_response()
      ? *response_.alloc_response_
      : *reinterpret_cast< ::message::Parkspace_allocation_response_msg*>(&::message::_Parkspace_allocation_response_msg_default_instance_);
}
inline const ::message::Parkspace_allocation_response_msg& Node_log::alloc_response() const {
  // @@protoc_insertion_point(field_get:message.Node_log.alloc_response)
  return _internal_alloc_response();
}
inline ::message::Parkspace_allocation_response_msg* Node_log::unsafe_arena_release_alloc_response() {
  // @@protoc_insertion_point(field_unsafe_arena_release:message.Node_log.alloc_response)
  if (_internal_has_alloc_response()) {
    clear_has_response();
    ::message::Parkspace_allocation_response_msg* temp = response_.alloc_response_;
    response_.alloc_response_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node_log::unsafe_arena_set_allocated_alloc_response(::message::Parkspace_allocation_response_msg* alloc_response) {
  clear_response();
  if (alloc_response) {
    set_has_alloc_response();
    response_.alloc_response_ = alloc_response;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:message.Node_log.alloc_response)
}
inline ::message::Parkspace_allocation_response_msg* Node_log::_internal_mutable_alloc_response() {
  if (!_internal_has_alloc_response()) {
    clear_response();
    set_has_alloc_response();
    response_.alloc_response_ = CreateMaybeMessage< ::message::Parkspace_allocation_response_msg >(GetArena());
  }
  return response_.alloc_response_;
}
inline ::message::Parkspace_allocation_response_msg* Node_log::mutable_alloc_response() {
  // @@protoc_insertion_point(field_mutable:message.Node_log.alloc_response)
  return _internal_mutable_alloc_response();
}

// .message.Parkspace_search_response_msg search_response = 4;
inline bool Node_log::_internal_has_search_response() const {
  return response_case() == kSearchResponse;
}
inline bool Node_log::has_search_response() const {
  return _internal_has_search_response();
}
inline void Node_log::set_has_search_response() {
  _oneof_case_[1] = kSearchResponse;
}
inline ::message::Parkspace_search_response_msg* Node_log::release_search_response() {
  // @@protoc_insertion_point(field_release:message.Node_log.search_response)
  if (_internal_has_search_response()) {
    clear_has_response();
      ::message::Parkspace_search_response_msg* temp = response_.search_response_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    response_.search_response_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::message::Parkspace_search_response_msg& Node_log::_internal_search_response() const {
  return _internal_has_search_response()
      ? *response_.search_response_
      : *reinterpret_cast< ::message::Parkspace_search_response_msg*>(&::message::_Parkspace_search_response_msg_default_instance_);
}
inline const ::message::Parkspace_search_response_msg& Node_log::search_response() const {
  // @@protoc_insertion_point(field_get:message.Node_log.search_response)
  return _internal_search_response();
}
inline ::message::Parkspace_search_response_msg* Node_log::unsafe_arena_release_search_response() {
  // @@protoc_insertion_point(field_unsafe_arena_release:message.Node_log.search_response)
  if (_internal_has_search_response()) {
    clear_has_response();
    ::message::Parkspace_search_response_msg* temp = response_.search_response_;
    response_.search_response_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node_log::unsafe_arena_set_allocated_search_response(::message::Parkspace_search_response_msg* search_response) {
  clear_response();
  if (search_response) {
    set_has_search_response();
    response_.search_response_ = search_response;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:message.Node_log.search_response)
}
inline ::message::Parkspace_search_response_msg* Node_log::_internal_mutable_search_response() {
  if (!_internal_has_search_response()) {
    clear_response();
    set_has_search_response();
    response_.search_response_ = CreateMaybeMessage< ::message::Parkspace_search_response_msg >(GetArena());
  }
  return response_.search_response_;
}
inline ::message::Parkspace_search_response_msg* Node_log::mutable_search_response() {
  // @@protoc_insertion_point(field_mutable:message.Node_log.search_response)
  return _internal_mutable_search_response();
}

// .message.Parkspace_release_response_msg release_response = 6;
inline bool Node_log::_internal_has_release_response() const {
  return response_case() == kReleaseResponse;
}
inline bool Node_log::has_release_response() const {
  return _internal_has_release_response();
}
inline void Node_log::set_has_release_response() {
  _oneof_case_[1] = kReleaseResponse;
}
inline ::message::Parkspace_release_response_msg* Node_log::release_release_response() {
  // @@protoc_insertion_point(field_release:message.Node_log.release_response)
  if (_internal_has_release_response()) {
    clear_has_response();
      ::message::Parkspace_release_response_msg* temp = response_.release_response_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    response_.release_response_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::message::Parkspace_release_response_msg& Node_log::_internal_release_response() const {
  return _internal_has_release_response()
      ? *response_.release_response_
      : *reinterpret_cast< ::message::Parkspace_release_response_msg*>(&::message::_Parkspace_release_response_msg_default_instance_);
}
inline const ::message::Parkspace_release_response_msg& Node_log::release_response() const {
  // @@protoc_insertion_point(field_get:message.Node_log.release_response)
  return _internal_release_response();
}
inline ::message::Parkspace_release_response_msg* Node_log::unsafe_arena_release_release_response() {
  // @@protoc_insertion_point(field_unsafe_arena_release:message.Node_log.release_response)
  if (_internal_has_release_response()) {
    clear_has_response();
    ::message::Parkspace_release_response_msg* temp = response_.release_response_;
    response_.release_response_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node_log::unsafe_arena_set_allocated_release_response(::message::Parkspace_release_response_msg* release_response) {
  clear_response();
  if (release_response) {
    set_has_release_response();
    response_.release_response_ = release_response;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:message.Node_log.release_response)
}
inline ::message::Parkspace_release_response_msg* Node_log::_internal_mutable_release_response() {
  if (!_internal_has_release_response()) {
    clear_response();
    set_has_release_response();
    response_.release_response_ = CreateMaybeMessage< ::message::Parkspace_release_response_msg >(GetArena());
  }
  return response_.release_response_;
}
inline ::message::Parkspace_release_response_msg* Node_log::mutable_release_response() {
  // @@protoc_insertion_point(field_mutable:message.Node_log.release_response)
  return _internal_mutable_release_response();
}

// .message.Parkspace_confirm_alloc_response_msg confirm_response = 8;
inline bool Node_log::_internal_has_confirm_response() const {
  return response_case() == kConfirmResponse;
}
inline bool Node_log::has_confirm_response() const {
  return _internal_has_confirm_response();
}
inline void Node_log::set_has_confirm_response() {
  _oneof_case_[1] = kConfirmResponse;
}
inline ::message::Parkspace_confirm_alloc_response_msg* Node_log::release_confirm_response() {
  // @@protoc_insertion_point(field_release:message.Node_log.confirm_response)
  if (_internal_has_confirm_response()) {
    clear_has_response();
      ::message::Parkspace_confirm_alloc_response_msg* temp = response_.confirm_response_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    response_.confirm_response_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::message::Parkspace_confirm_alloc_response_msg& Node_log::_internal_confirm_response() const {
  return _internal_has_confirm_response()
      ? *response_.confirm_response_
      : *reinterpret_cast< ::message::Parkspace_confirm_alloc_response_msg*>(&::message::_Parkspace_confirm_alloc_response_msg_default_instance_);
}
inline const ::message::Parkspace_confirm_alloc_response_msg& Node_log::confirm_response() const {
  // @@protoc_insertion_point(field_get:message.Node_log.confirm_response)
  return _internal_confirm_response();
}
inline ::message::Parkspace_confirm_alloc_response_msg* Node_log::unsafe_arena_release_confirm_response() {
  // @@protoc_insertion_point(field_unsafe_arena_release:message.Node_log.confirm_response)
  if (_internal_has_confirm_response()) {
    clear_has_response();
    ::message::Parkspace_confirm_alloc_response_msg* temp = response_.confirm_response_;
    response_.confirm_response_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node_log::unsafe_arena_set_allocated_confirm_response(::message::Parkspace_confirm_alloc_response_msg* confirm_response) {
  clear_response();
  if (confirm_response) {
    set_has_confirm_response();
    response_.confirm_response_ = confirm_response;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:message.Node_log.confirm_response)
}
inline ::message::Parkspace_confirm_alloc_response_msg* Node_log::_internal_mutable_confirm_response() {
  if (!_internal_has_confirm_response()) {
    clear_response();
    set_has_confirm_response();
    response_.confirm_response_ = CreateMaybeMessage< ::message::Parkspace_confirm_alloc_response_msg >(GetArena());
  }
  return response_.confirm_response_;
}
inline ::message::Parkspace_confirm_alloc_response_msg* Node_log::mutable_confirm_response() {
  // @@protoc_insertion_point(field_mutable:message.Node_log.confirm_response)
  return _internal_mutable_confirm_response();
}

// .message.Measure_response_msg measure_response = 10;
inline bool Node_log::_internal_has_measure_response() const {
  return response_case() == kMeasureResponse;
}
inline bool Node_log::has_measure_response() const {
  return _internal_has_measure_response();
}
inline void Node_log::set_has_measure_response() {
  _oneof_case_[1] = kMeasureResponse;
}
inline ::message::Measure_response_msg* Node_log::release_measure_response() {
  // @@protoc_insertion_point(field_release:message.Node_log.measure_response)
  if (_internal_has_measure_response()) {
    clear_has_response();
      ::message::Measure_response_msg* temp = response_.measure_response_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    response_.measure_response_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::message::Measure_response_msg& Node_log::_internal_measure_response() const {
  return _internal_has_measure_response()
      ? *response_.measure_response_
      : *reinterpret_cast< ::message::Measure_response_msg*>(&::message::_Measure_response_msg_default_instance_);
}
inline const ::message::Measure_response_msg& Node_log::measure_response() const {
  // @@protoc_insertion_point(field_get:message.Node_log.measure_response)
  return _internal_measure_response();
}
inline ::message::Measure_response_msg* Node_log::unsafe_arena_release_measure_response() {
  // @@protoc_insertion_point(field_unsafe_arena_release:message.Node_log.measure_response)
  if (_internal_has_measure_response()) {
    clear_has_response();
    ::message::Measure_response_msg* temp = response_.measure_response_;
    response_.measure_response_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node_log::unsafe_arena_set_allocated_measure_response(::message::Measure_response_msg* measure_response) {
  clear_response();
  if (measure_response) {
    set_has_measure_response();
    response_.measure_response_ = measure_response;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:message.Node_log.measure_response)
}
inline ::message::Measure_response_msg* Node_log::_internal_mutable_measure_response() {
  if (!_internal_has_measure_response()) {
    clear_response();
    set_has_measure_response();
    response_.measure_response_ = CreateMaybeMessage< ::message::Measure_response_msg >(GetArena());
  }
  return response_.measure_response_;
}
inline ::message::Measure_response_msg* Node_log::mutable_measure_response() {
  // @@protoc_insertion_point(field_mutable:message.Node_log.measure_response)
  return _internal_mutable_measure_response();
}

// .message.Dispatch_response_msg dispatch_response = 12;
inline bool Node_log::_internal_has_dispatch_response() const {
  return response_case() == kDispatchResponse;
}
inline bool Node_log::has_dispatch_response() const {
  return _internal_has_dispatch_response();
}
inline void Node_log::set_has_dispatch_response() {
  _oneof_case_[1] = kDispatchResponse;
}
inline ::message::Dispatch_response_msg* Node_log::release_dispatch_response() {
  // @@protoc_insertion_point(field_release:message.Node_log.dispatch_response)
  if (_internal_has_dispatch_response()) {
    clear_has_response();
      ::message::Dispatch_response_msg* temp = response_.dispatch_response_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    response_.dispatch_response_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::message::Dispatch_response_msg& Node_log::_internal_dispatch_response() const {
  return _internal_has_dispatch_response()
      ? *response_.dispatch_response_
      : *reinterpret_cast< ::message::Dispatch_response_msg*>(&::message::_Dispatch_response_msg_default_instance_);
}
inline const ::message::Dispatch_response_msg& Node_log::dispatch_response() const {
  // @@protoc_insertion_point(field_get:message.Node_log.dispatch_response)
  return _internal_dispatch_response();
}
inline ::message::Dispatch_response_msg* Node_log::unsafe_arena_release_dispatch_response() {
  // @@protoc_insertion_point(field_unsafe_arena_release:message.Node_log.dispatch_response)
  if (_internal_has_dispatch_response()) {
    clear_has_response();
    ::message::Dispatch_response_msg* temp = response_.dispatch_response_;
    response_.dispatch_response_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Node_log::unsafe_arena_set_allocated_dispatch_response(::message::Dispatch_response_msg* dispatch_response) {
  clear_response();
  if (dispatch_response) {
    set_has_dispatch_response();
    response_.dispatch_response_ = dispatch_response;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:message.Node_log.dispatch_response)
}
inline ::message::Dispatch_response_msg* Node_log::_internal_mutable_dispatch_response() {
  if (!_internal_has_dispatch_response()) {
    clear_response();
    set_has_dispatch_response();
    response_.dispatch_response_ = CreateMaybeMessage< ::message::Dispatch_response_msg >(GetArena());
  }
  return response_.dispatch_response_;
}
inline ::message::Dispatch_response_msg* Node_log::mutable_dispatch_response() {
  // @@protoc_insertion_point(field_mutable:message.Node_log.dispatch_response)
  return _internal_mutable_dispatch_response();
}

// optional string description = 13;
inline bool Node_log::_internal_has_description() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Node_log::has_description() const {
  return _internal_has_description();
}
inline void Node_log::clear_description() {
  description_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Node_log::description() const {
  // @@protoc_insertion_point(field_get:message.Node_log.description)
  return _internal_description();
}
inline void Node_log::set_description(const std::string& value) {
  _internal_set_description(value);
  // @@protoc_insertion_point(field_set:message.Node_log.description)
}
inline std::string* Node_log::mutable_description() {
  // @@protoc_insertion_point(field_mutable:message.Node_log.description)
  return _internal_mutable_description();
}
inline const std::string& Node_log::_internal_description() const {
  return description_.Get();
}
inline void Node_log::_internal_set_description(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  description_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void Node_log::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.Node_log.description)
}
inline void Node_log::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.Node_log.description)
}
inline void Node_log::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.Node_log.description)
}
inline std::string* Node_log::_internal_mutable_description() {
  _has_bits_[0] |= 0x00000001u;
  return description_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* Node_log::release_description() {
  // @@protoc_insertion_point(field_release:message.Node_log.description)
  if (!_internal_has_description()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return description_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Node_log::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.Node_log.description)
}

inline bool Node_log::has_request() const {
  return request_case() != REQUEST_NOT_SET;
}
inline void Node_log::clear_has_request() {
  _oneof_case_[0] = REQUEST_NOT_SET;
}
inline bool Node_log::has_response() const {
  return response_case() != RESPONSE_NOT_SET;
}
inline void Node_log::clear_has_response() {
  _oneof_case_[1] = RESPONSE_NOT_SET;
}
inline Node_log::RequestCase Node_log::request_case() const {
  return Node_log::RequestCase(_oneof_case_[0]);
}
inline Node_log::ResponseCase Node_log::response_case() const {
  return Node_log::ResponseCase(_oneof_case_[1]);
}
// -------------------------------------------------------------------

// Manual_operation_log

// required .message.Process_manual_operation_msg manual_operation = 1;
inline bool Manual_operation_log::_internal_has_manual_operation() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || manual_operation_ != nullptr);
  return value;
}
inline bool Manual_operation_log::has_manual_operation() const {
  return _internal_has_manual_operation();
}
inline const ::message::Process_manual_operation_msg& Manual_operation_log::_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_log::manual_operation() const {
  // @@protoc_insertion_point(field_get:message.Manual_operation_log.manual_operation)
  return _internal_manual_operation();
}
inline void Manual_operation_log::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_log.manual_operation)
}
inline ::message::Process_manual_operation_msg* Manual_operation_log::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_log::unsafe_arena_release_manual_operation() {
  // @@protoc_insertion_point(field_release:message.Manual_operation_log.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_log::_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_log::mutable_manual_operation() {
  // @@protoc_insertion_point(field_mutable:message.Manual_operation_log.manual_operation)
  return _internal_mutable_manual_operation();
}
inline void Manual_operation_log::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_log.manual_operation)
}

// optional string description = 2;
inline bool Manual_operation_log::_internal_has_description() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Manual_operation_log::has_description() const {
  return _internal_has_description();
}
inline void Manual_operation_log::clear_description() {
  description_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Manual_operation_log::description() const {
  // @@protoc_insertion_point(field_get:message.Manual_operation_log.description)
  return _internal_description();
}
inline void Manual_operation_log::set_description(const std::string& value) {
  _internal_set_description(value);
  // @@protoc_insertion_point(field_set:message.Manual_operation_log.description)
}
inline std::string* Manual_operation_log::mutable_description() {
  // @@protoc_insertion_point(field_mutable:message.Manual_operation_log.description)
  return _internal_mutable_description();
}
inline const std::string& Manual_operation_log::_internal_description() const {
  return description_.Get();
}
inline void Manual_operation_log::_internal_set_description(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  description_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void Manual_operation_log::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_log.description)
}
inline void Manual_operation_log::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_log.description)
}
inline void Manual_operation_log::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_log.description)
}
inline std::string* Manual_operation_log::_internal_mutable_description() {
  _has_bits_[0] |= 0x00000001u;
  return description_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* Manual_operation_log::release_description() {
  // @@protoc_insertion_point(field_release:message.Manual_operation_log.description)
  if (!_internal_has_description()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return description_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Manual_operation_log::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_log.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.Node_log node_log = 3;
inline bool Log_data::_internal_has_node_log() const {
  return data_case() == kNodeLog;
}
inline bool Log_data::has_node_log() const {
  return _internal_has_node_log();
}
inline void Log_data::set_has_node_log() {
  _oneof_case_[0] = kNodeLog;
}
inline void Log_data::clear_node_log() {
  if (_internal_has_node_log()) {
    if (GetArena() == nullptr) {
      delete data_.node_log_;
    }
    clear_has_data();
  }
}
inline ::message::Node_log* Log_data::release_node_log() {
  // @@protoc_insertion_point(field_release:message.Log_data.node_log)
  if (_internal_has_node_log()) {
    clear_has_data();
      ::message::Node_log* temp = data_.node_log_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    data_.node_log_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::message::Node_log& Log_data::_internal_node_log() const {
  return _internal_has_node_log()
      ? *data_.node_log_
      : *reinterpret_cast< ::message::Node_log*>(&::message::_Node_log_default_instance_);
}
inline const ::message::Node_log& Log_data::node_log() const {
  // @@protoc_insertion_point(field_get:message.Log_data.node_log)
  return _internal_node_log();
}
inline ::message::Node_log* Log_data::unsafe_arena_release_node_log() {
  // @@protoc_insertion_point(field_unsafe_arena_release:message.Log_data.node_log)
  if (_internal_has_node_log()) {
    clear_has_data();
    ::message::Node_log* temp = data_.node_log_;
    data_.node_log_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Log_data::unsafe_arena_set_allocated_node_log(::message::Node_log* node_log) {
  clear_data();
  if (node_log) {
    set_has_node_log();
    data_.node_log_ = node_log;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:message.Log_data.node_log)
}
inline ::message::Node_log* Log_data::_internal_mutable_node_log() {
  if (!_internal_has_node_log()) {
    clear_data();
    set_has_node_log();
    data_.node_log_ = CreateMaybeMessage< ::message::Node_log >(GetArena());
  }
  return data_.node_log_;
}
inline ::message::Node_log* Log_data::mutable_node_log() {
  // @@protoc_insertion_point(field_mutable:message.Log_data.node_log)
  return _internal_mutable_node_log();
}

// .message.Manual_operation_log manual_operator_log = 4;
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_log* 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_log* 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_log& Log_data::_internal_manual_operator_log() const {
  return _internal_has_manual_operator_log()
      ? *data_.manual_operator_log_
      : *reinterpret_cast< ::message::Manual_operation_log*>(&::message::_Manual_operation_log_default_instance_);
}
inline const ::message::Manual_operation_log& 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_log* 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_log* 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_log* 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_log* 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_log >(GetArena());
  }
  return data_.manual_operator_log_;
}
inline ::message::Manual_operation_log* 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
