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

#ifndef PROTOBUF_INCLUDED_log_5fprocess_2eproto
#define PROTOBUF_INCLUDED_log_5fprocess_2eproto

#include <string>

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

#if GOOGLE_PROTOBUF_VERSION < 3006001
#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 3006001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers.  Please
#error regenerate this file with a newer version of protoc.
#endif

#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_table_driven.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/inlined_string_field.h>
#include <google/protobuf/metadata.h>
#include <google/protobuf/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)
#define PROTOBUF_INTERNAL_EXPORT_protobuf_log_5fprocess_2eproto 

namespace protobuf_log_5fprocess_2eproto {
// Internal implementation detail -- do not use these members.
struct TableStruct {
  static const ::google::protobuf::internal::ParseTableField entries[];
  static const ::google::protobuf::internal::AuxillaryParseTableField aux[];
  static const ::google::protobuf::internal::ParseTable schema[4];
  static const ::google::protobuf::internal::FieldMetadata field_metadata[];
  static const ::google::protobuf::internal::SerializationTable serialization_table[];
  static const ::google::protobuf::uint32 offsets[];
};
void AddDescriptors();
}  // namespace protobuf_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
namespace google {
namespace protobuf {
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*);
}  // namespace protobuf
}  // namespace google
namespace message {

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

const ::google::protobuf::EnumDescriptor* Log_data_Severity_descriptor();
inline const ::std::string& Log_data_Severity_Name(Log_data_Severity value) {
  return ::google::protobuf::internal::NameOfEnum(
    Log_data_Severity_descriptor(), value);
}
inline bool Log_data_Severity_Parse(
    const ::std::string& name, Log_data_Severity* value) {
  return ::google::protobuf::internal::ParseNamedEnum<Log_data_Severity>(
    Log_data_Severity_descriptor(), name, value);
}
// ===================================================================

class Node_log : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:message.Node_log) */ {
 public:
  Node_log();
  virtual ~Node_log();

  Node_log(const Node_log& from);

  inline Node_log& operator=(const Node_log& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  Node_log(Node_log&& from) noexcept
    : Node_log() {
    *this = ::std::move(from);
  }

  inline Node_log& operator=(Node_log&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  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;

  void Swap(Node_log* other);
  friend void swap(Node_log& a, Node_log& b) {
    a.Swap(&b);
  }

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

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

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

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Node_log* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

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

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

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

  // optional string description = 13;
  bool has_description() const;
  void clear_description();
  static const int kDescriptionFieldNumber = 13;
  const ::std::string& description() const;
  void set_description(const ::std::string& value);
  #if LANG_CXX11
  void set_description(::std::string&& value);
  #endif
  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);

  // optional .message.Parkspace_allocation_request_msg alloc_request = 1;
  bool has_alloc_request() const;
  void clear_alloc_request();
  static const int kAllocRequestFieldNumber = 1;
  private:
  const ::message::Parkspace_allocation_request_msg& _internal_alloc_request() const;
  public:
  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);

  // optional .message.Parkspace_search_request_msg search_request = 3;
  bool has_search_request() const;
  void clear_search_request();
  static const int kSearchRequestFieldNumber = 3;
  private:
  const ::message::Parkspace_search_request_msg& _internal_search_request() const;
  public:
  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);

  // optional .message.Parkspace_release_request_msg release_request = 5;
  bool has_release_request() const;
  void clear_release_request();
  static const int kReleaseRequestFieldNumber = 5;
  private:
  const ::message::Parkspace_release_request_msg& _internal_release_request() const;
  public:
  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);

  // optional .message.Parkspace_confirm_alloc_request_msg confirm_request = 7;
  bool has_confirm_request() const;
  void clear_confirm_request();
  static const int kConfirmRequestFieldNumber = 7;
  private:
  const ::message::Parkspace_confirm_alloc_request_msg& _internal_confirm_request() const;
  public:
  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);

  // optional .message.Measure_request_msg measure_request = 9;
  bool has_measure_request() const;
  void clear_measure_request();
  static const int kMeasureRequestFieldNumber = 9;
  private:
  const ::message::Measure_request_msg& _internal_measure_request() const;
  public:
  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);

  // optional .message.Dispatch_request_msg dispatch_request = 11;
  bool has_dispatch_request() const;
  void clear_dispatch_request();
  static const int kDispatchRequestFieldNumber = 11;
  private:
  const ::message::Dispatch_request_msg& _internal_dispatch_request() const;
  public:
  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);

  // optional .message.Parkspace_allocation_response_msg alloc_response = 2;
  bool has_alloc_response() const;
  void clear_alloc_response();
  static const int kAllocResponseFieldNumber = 2;
  private:
  const ::message::Parkspace_allocation_response_msg& _internal_alloc_response() const;
  public:
  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);

  // optional .message.Parkspace_search_response_msg search_response = 4;
  bool has_search_response() const;
  void clear_search_response();
  static const int kSearchResponseFieldNumber = 4;
  private:
  const ::message::Parkspace_search_response_msg& _internal_search_response() const;
  public:
  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);

  // optional .message.Parkspace_release_response_msg release_response = 6;
  bool has_release_response() const;
  void clear_release_response();
  static const int kReleaseResponseFieldNumber = 6;
  private:
  const ::message::Parkspace_release_response_msg& _internal_release_response() const;
  public:
  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);

  // optional .message.Parkspace_confirm_alloc_response_msg confirm_response = 8;
  bool has_confirm_response() const;
  void clear_confirm_response();
  static const int kConfirmResponseFieldNumber = 8;
  private:
  const ::message::Parkspace_confirm_alloc_response_msg& _internal_confirm_response() const;
  public:
  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);

  // optional .message.Measure_response_msg measure_response = 10;
  bool has_measure_response() const;
  void clear_measure_response();
  static const int kMeasureResponseFieldNumber = 10;
  private:
  const ::message::Measure_response_msg& _internal_measure_response() const;
  public:
  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);

  // optional .message.Dispatch_response_msg dispatch_response = 12;
  bool has_dispatch_response() const;
  void clear_dispatch_response();
  static const int kDispatchResponseFieldNumber = 12;
  private:
  const ::message::Dispatch_response_msg& _internal_dispatch_response() const;
  public:
  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);

  void clear_request();
  RequestCase request_case() const;
  void clear_response();
  ResponseCase response_case() const;
  // @@protoc_insertion_point(class_scope:message.Node_log)
 private:
  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();
  void set_has_description();
  void clear_has_description();

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

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

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::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_;
  ::google::protobuf::uint32 _oneof_case_[2];

  friend struct ::protobuf_log_5fprocess_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class Manual_operation_log : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:message.Manual_operation_log) */ {
 public:
  Manual_operation_log();
  virtual ~Manual_operation_log();

  Manual_operation_log(const Manual_operation_log& from);

  inline Manual_operation_log& operator=(const Manual_operation_log& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  Manual_operation_log(Manual_operation_log&& from) noexcept
    : Manual_operation_log() {
    *this = ::std::move(from);
  }

  inline Manual_operation_log& operator=(Manual_operation_log&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  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;

  void Swap(Manual_operation_log* other);
  friend void swap(Manual_operation_log& a, Manual_operation_log& b) {
    a.Swap(&b);
  }

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

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

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

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Manual_operation_log* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

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

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

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

  // optional string description = 2;
  bool has_description() const;
  void clear_description();
  static const int kDescriptionFieldNumber = 2;
  const ::std::string& description() const;
  void set_description(const ::std::string& value);
  #if LANG_CXX11
  void set_description(::std::string&& value);
  #endif
  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);

  // required .message.Process_manual_operation_msg manual_operation = 1;
  bool has_manual_operation() const;
  void clear_manual_operation();
  static const int kManualOperationFieldNumber = 1;
  private:
  const ::message::Process_manual_operation_msg& _internal_manual_operation() const;
  public:
  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);

  // @@protoc_insertion_point(class_scope:message.Manual_operation_log)
 private:
  void set_has_manual_operation();
  void clear_has_manual_operation();
  void set_has_description();
  void clear_has_description();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr description_;
  ::message::Process_manual_operation_msg* manual_operation_;
  friend struct ::protobuf_log_5fprocess_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class Log_data : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:message.Log_data) */ {
 public:
  Log_data();
  virtual ~Log_data();

  Log_data(const Log_data& from);

  inline Log_data& operator=(const Log_data& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  Log_data(Log_data&& from) noexcept
    : Log_data() {
    *this = ::std::move(from);
  }

  inline Log_data& operator=(Log_data&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  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;

  void Swap(Log_data* other);
  friend void swap(Log_data& a, Log_data& b) {
    a.Swap(&b);
  }

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

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

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

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Log_data* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

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

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

  typedef Log_data_Severity Severity;
  static const Severity INFO =
    Log_data_Severity_INFO;
  static const Severity WARNING =
    Log_data_Severity_WARNING;
  static const Severity ERROR =
    Log_data_Severity_ERROR;
  static inline bool Severity_IsValid(int value) {
    return Log_data_Severity_IsValid(value);
  }
  static const Severity Severity_MIN =
    Log_data_Severity_Severity_MIN;
  static const Severity Severity_MAX =
    Log_data_Severity_Severity_MAX;
  static const int Severity_ARRAYSIZE =
    Log_data_Severity_Severity_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  Severity_descriptor() {
    return Log_data_Severity_descriptor();
  }
  static inline const ::std::string& Severity_Name(Severity value) {
    return Log_data_Severity_Name(value);
  }
  static inline bool Severity_Parse(const ::std::string& name,
      Severity* value) {
    return Log_data_Severity_Parse(name, value);
  }

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

  // required .message.Log_data.Severity log_severity = 1;
  bool has_log_severity() const;
  void clear_log_severity();
  static const int kLogSeverityFieldNumber = 1;
  ::message::Log_data_Severity log_severity() const;
  void set_log_severity(::message::Log_data_Severity value);

  // optional string str_log = 2;
  bool has_str_log() const;
  void clear_str_log();
  static const int kStrLogFieldNumber = 2;
  const ::std::string& str_log() const;
  void set_str_log(const ::std::string& value);
  #if LANG_CXX11
  void set_str_log(::std::string&& value);
  #endif
  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);

  // optional .message.Node_log node_log = 3;
  bool has_node_log() const;
  void clear_node_log();
  static const int kNodeLogFieldNumber = 3;
  private:
  const ::message::Node_log& _internal_node_log() const;
  public:
  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);

  // optional .message.Manual_operation_log manual_operator_log = 4;
  bool has_manual_operator_log() const;
  void clear_manual_operator_log();
  static const int kManualOperatorLogFieldNumber = 4;
  private:
  const ::message::Manual_operation_log& _internal_manual_operator_log() const;
  public:
  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);

  void clear_data();
  DataCase data_case() const;
  // @@protoc_insertion_point(class_scope:message.Log_data)
 private:
  void set_has_log_severity();
  void clear_has_log_severity();
  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();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  int log_severity_;
  union DataUnion {
    DataUnion() {}
    ::google::protobuf::internal::ArenaStringPtr str_log_;
    ::message::Node_log* node_log_;
    ::message::Manual_operation_log* manual_operator_log_;
  } data_;
  ::google::protobuf::uint32 _oneof_case_[1];

  friend struct ::protobuf_log_5fprocess_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class Process_log : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:message.Process_log) */ {
 public:
  Process_log();
  virtual ~Process_log();

  Process_log(const Process_log& from);

  inline Process_log& operator=(const Process_log& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  Process_log(Process_log&& from) noexcept
    : Process_log() {
    *this = ::std::move(from);
  }

  inline Process_log& operator=(Process_log&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  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;

  void Swap(Process_log* other);
  friend void swap(Process_log& a, Process_log& b) {
    a.Swap(&b);
  }

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

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

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

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Process_log* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

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

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

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

  // repeated .message.Log_data log_data = 2;
  int log_data_size() const;
  void clear_log_data();
  static const int kLogDataFieldNumber = 2;
  ::message::Log_data* mutable_log_data(int index);
  ::google::protobuf::RepeatedPtrField< ::message::Log_data >*
      mutable_log_data();
  const ::message::Log_data& log_data(int index) const;
  ::message::Log_data* add_log_data();
  const ::google::protobuf::RepeatedPtrField< ::message::Log_data >&
      log_data() const;

  // required .message.Process_type process_type = 1;
  bool has_process_type() const;
  void clear_process_type();
  static const int kProcessTypeFieldNumber = 1;
  ::message::Process_type process_type() const;
  void set_process_type(::message::Process_type value);

  // @@protoc_insertion_point(class_scope:message.Process_log)
 private:
  void set_has_process_type();
  void clear_has_process_type();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::RepeatedPtrField< ::message::Log_data > log_data_;
  int process_type_;
  friend struct ::protobuf_log_5fprocess_2eproto::TableStruct;
};
// ===================================================================


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

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

// optional .message.Parkspace_allocation_request_msg alloc_request = 1;
inline bool Node_log::has_alloc_request() const {
  return request_case() == kAllocRequest;
}
inline void Node_log::set_has_alloc_request() {
  _oneof_case_[0] = kAllocRequest;
}
inline const ::message::Parkspace_allocation_request_msg& Node_log::_internal_alloc_request() const {
  return *request_.alloc_request_;
}
inline ::message::Parkspace_allocation_request_msg* Node_log::release_alloc_request() {
  // @@protoc_insertion_point(field_release:message.Node_log.alloc_request)
  if (has_alloc_request()) {
    clear_has_request();
      ::message::Parkspace_allocation_request_msg* temp = request_.alloc_request_;
    request_.alloc_request_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::message::Parkspace_allocation_request_msg& Node_log::alloc_request() const {
  // @@protoc_insertion_point(field_get:message.Node_log.alloc_request)
  return has_alloc_request()
      ? *request_.alloc_request_
      : *reinterpret_cast< ::message::Parkspace_allocation_request_msg*>(&::message::_Parkspace_allocation_request_msg_default_instance_);
}
inline ::message::Parkspace_allocation_request_msg* Node_log::mutable_alloc_request() {
  if (!has_alloc_request()) {
    clear_request();
    set_has_alloc_request();
    request_.alloc_request_ = CreateMaybeMessage< ::message::Parkspace_allocation_request_msg >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:message.Node_log.alloc_request)
  return request_.alloc_request_;
}

// optional .message.Parkspace_search_request_msg search_request = 3;
inline bool Node_log::has_search_request() const {
  return request_case() == kSearchRequest;
}
inline void Node_log::set_has_search_request() {
  _oneof_case_[0] = kSearchRequest;
}
inline const ::message::Parkspace_search_request_msg& Node_log::_internal_search_request() const {
  return *request_.search_request_;
}
inline ::message::Parkspace_search_request_msg* Node_log::release_search_request() {
  // @@protoc_insertion_point(field_release:message.Node_log.search_request)
  if (has_search_request()) {
    clear_has_request();
      ::message::Parkspace_search_request_msg* temp = request_.search_request_;
    request_.search_request_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::message::Parkspace_search_request_msg& Node_log::search_request() const {
  // @@protoc_insertion_point(field_get:message.Node_log.search_request)
  return has_search_request()
      ? *request_.search_request_
      : *reinterpret_cast< ::message::Parkspace_search_request_msg*>(&::message::_Parkspace_search_request_msg_default_instance_);
}
inline ::message::Parkspace_search_request_msg* Node_log::mutable_search_request() {
  if (!has_search_request()) {
    clear_request();
    set_has_search_request();
    request_.search_request_ = CreateMaybeMessage< ::message::Parkspace_search_request_msg >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:message.Node_log.search_request)
  return request_.search_request_;
}

// optional .message.Parkspace_release_request_msg release_request = 5;
inline bool Node_log::has_release_request() const {
  return request_case() == kReleaseRequest;
}
inline void Node_log::set_has_release_request() {
  _oneof_case_[0] = kReleaseRequest;
}
inline const ::message::Parkspace_release_request_msg& Node_log::_internal_release_request() const {
  return *request_.release_request_;
}
inline ::message::Parkspace_release_request_msg* Node_log::release_release_request() {
  // @@protoc_insertion_point(field_release:message.Node_log.release_request)
  if (has_release_request()) {
    clear_has_request();
      ::message::Parkspace_release_request_msg* temp = request_.release_request_;
    request_.release_request_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::message::Parkspace_release_request_msg& Node_log::release_request() const {
  // @@protoc_insertion_point(field_get:message.Node_log.release_request)
  return has_release_request()
      ? *request_.release_request_
      : *reinterpret_cast< ::message::Parkspace_release_request_msg*>(&::message::_Parkspace_release_request_msg_default_instance_);
}
inline ::message::Parkspace_release_request_msg* Node_log::mutable_release_request() {
  if (!has_release_request()) {
    clear_request();
    set_has_release_request();
    request_.release_request_ = CreateMaybeMessage< ::message::Parkspace_release_request_msg >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:message.Node_log.release_request)
  return request_.release_request_;
}

// optional .message.Parkspace_confirm_alloc_request_msg confirm_request = 7;
inline bool Node_log::has_confirm_request() const {
  return request_case() == kConfirmRequest;
}
inline void Node_log::set_has_confirm_request() {
  _oneof_case_[0] = kConfirmRequest;
}
inline const ::message::Parkspace_confirm_alloc_request_msg& Node_log::_internal_confirm_request() const {
  return *request_.confirm_request_;
}
inline ::message::Parkspace_confirm_alloc_request_msg* Node_log::release_confirm_request() {
  // @@protoc_insertion_point(field_release:message.Node_log.confirm_request)
  if (has_confirm_request()) {
    clear_has_request();
      ::message::Parkspace_confirm_alloc_request_msg* temp = request_.confirm_request_;
    request_.confirm_request_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::message::Parkspace_confirm_alloc_request_msg& Node_log::confirm_request() const {
  // @@protoc_insertion_point(field_get:message.Node_log.confirm_request)
  return has_confirm_request()
      ? *request_.confirm_request_
      : *reinterpret_cast< ::message::Parkspace_confirm_alloc_request_msg*>(&::message::_Parkspace_confirm_alloc_request_msg_default_instance_);
}
inline ::message::Parkspace_confirm_alloc_request_msg* Node_log::mutable_confirm_request() {
  if (!has_confirm_request()) {
    clear_request();
    set_has_confirm_request();
    request_.confirm_request_ = CreateMaybeMessage< ::message::Parkspace_confirm_alloc_request_msg >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:message.Node_log.confirm_request)
  return request_.confirm_request_;
}

// optional .message.Measure_request_msg measure_request = 9;
inline bool Node_log::has_measure_request() const {
  return request_case() == kMeasureRequest;
}
inline void Node_log::set_has_measure_request() {
  _oneof_case_[0] = kMeasureRequest;
}
inline const ::message::Measure_request_msg& Node_log::_internal_measure_request() const {
  return *request_.measure_request_;
}
inline ::message::Measure_request_msg* Node_log::release_measure_request() {
  // @@protoc_insertion_point(field_release:message.Node_log.measure_request)
  if (has_measure_request()) {
    clear_has_request();
      ::message::Measure_request_msg* temp = request_.measure_request_;
    request_.measure_request_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::message::Measure_request_msg& Node_log::measure_request() const {
  // @@protoc_insertion_point(field_get:message.Node_log.measure_request)
  return has_measure_request()
      ? *request_.measure_request_
      : *reinterpret_cast< ::message::Measure_request_msg*>(&::message::_Measure_request_msg_default_instance_);
}
inline ::message::Measure_request_msg* Node_log::mutable_measure_request() {
  if (!has_measure_request()) {
    clear_request();
    set_has_measure_request();
    request_.measure_request_ = CreateMaybeMessage< ::message::Measure_request_msg >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:message.Node_log.measure_request)
  return request_.measure_request_;
}

// optional .message.Dispatch_request_msg dispatch_request = 11;
inline bool Node_log::has_dispatch_request() const {
  return request_case() == kDispatchRequest;
}
inline void Node_log::set_has_dispatch_request() {
  _oneof_case_[0] = kDispatchRequest;
}
inline const ::message::Dispatch_request_msg& Node_log::_internal_dispatch_request() const {
  return *request_.dispatch_request_;
}
inline ::message::Dispatch_request_msg* Node_log::release_dispatch_request() {
  // @@protoc_insertion_point(field_release:message.Node_log.dispatch_request)
  if (has_dispatch_request()) {
    clear_has_request();
      ::message::Dispatch_request_msg* temp = request_.dispatch_request_;
    request_.dispatch_request_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::message::Dispatch_request_msg& Node_log::dispatch_request() const {
  // @@protoc_insertion_point(field_get:message.Node_log.dispatch_request)
  return has_dispatch_request()
      ? *request_.dispatch_request_
      : *reinterpret_cast< ::message::Dispatch_request_msg*>(&::message::_Dispatch_request_msg_default_instance_);
}
inline ::message::Dispatch_request_msg* Node_log::mutable_dispatch_request() {
  if (!has_dispatch_request()) {
    clear_request();
    set_has_dispatch_request();
    request_.dispatch_request_ = CreateMaybeMessage< ::message::Dispatch_request_msg >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:message.Node_log.dispatch_request)
  return request_.dispatch_request_;
}

// optional .message.Parkspace_allocation_response_msg alloc_response = 2;
inline bool Node_log::has_alloc_response() const {
  return response_case() == kAllocResponse;
}
inline void Node_log::set_has_alloc_response() {
  _oneof_case_[1] = kAllocResponse;
}
inline const ::message::Parkspace_allocation_response_msg& Node_log::_internal_alloc_response() const {
  return *response_.alloc_response_;
}
inline ::message::Parkspace_allocation_response_msg* Node_log::release_alloc_response() {
  // @@protoc_insertion_point(field_release:message.Node_log.alloc_response)
  if (has_alloc_response()) {
    clear_has_response();
      ::message::Parkspace_allocation_response_msg* temp = response_.alloc_response_;
    response_.alloc_response_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::message::Parkspace_allocation_response_msg& Node_log::alloc_response() const {
  // @@protoc_insertion_point(field_get:message.Node_log.alloc_response)
  return has_alloc_response()
      ? *response_.alloc_response_
      : *reinterpret_cast< ::message::Parkspace_allocation_response_msg*>(&::message::_Parkspace_allocation_response_msg_default_instance_);
}
inline ::message::Parkspace_allocation_response_msg* Node_log::mutable_alloc_response() {
  if (!has_alloc_response()) {
    clear_response();
    set_has_alloc_response();
    response_.alloc_response_ = CreateMaybeMessage< ::message::Parkspace_allocation_response_msg >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:message.Node_log.alloc_response)
  return response_.alloc_response_;
}

// optional .message.Parkspace_search_response_msg search_response = 4;
inline bool Node_log::has_search_response() const {
  return response_case() == kSearchResponse;
}
inline void Node_log::set_has_search_response() {
  _oneof_case_[1] = kSearchResponse;
}
inline const ::message::Parkspace_search_response_msg& Node_log::_internal_search_response() const {
  return *response_.search_response_;
}
inline ::message::Parkspace_search_response_msg* Node_log::release_search_response() {
  // @@protoc_insertion_point(field_release:message.Node_log.search_response)
  if (has_search_response()) {
    clear_has_response();
      ::message::Parkspace_search_response_msg* temp = response_.search_response_;
    response_.search_response_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::message::Parkspace_search_response_msg& Node_log::search_response() const {
  // @@protoc_insertion_point(field_get:message.Node_log.search_response)
  return has_search_response()
      ? *response_.search_response_
      : *reinterpret_cast< ::message::Parkspace_search_response_msg*>(&::message::_Parkspace_search_response_msg_default_instance_);
}
inline ::message::Parkspace_search_response_msg* Node_log::mutable_search_response() {
  if (!has_search_response()) {
    clear_response();
    set_has_search_response();
    response_.search_response_ = CreateMaybeMessage< ::message::Parkspace_search_response_msg >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:message.Node_log.search_response)
  return response_.search_response_;
}

// optional .message.Parkspace_release_response_msg release_response = 6;
inline bool Node_log::has_release_response() const {
  return response_case() == kReleaseResponse;
}
inline void Node_log::set_has_release_response() {
  _oneof_case_[1] = kReleaseResponse;
}
inline const ::message::Parkspace_release_response_msg& Node_log::_internal_release_response() const {
  return *response_.release_response_;
}
inline ::message::Parkspace_release_response_msg* Node_log::release_release_response() {
  // @@protoc_insertion_point(field_release:message.Node_log.release_response)
  if (has_release_response()) {
    clear_has_response();
      ::message::Parkspace_release_response_msg* temp = response_.release_response_;
    response_.release_response_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::message::Parkspace_release_response_msg& Node_log::release_response() const {
  // @@protoc_insertion_point(field_get:message.Node_log.release_response)
  return has_release_response()
      ? *response_.release_response_
      : *reinterpret_cast< ::message::Parkspace_release_response_msg*>(&::message::_Parkspace_release_response_msg_default_instance_);
}
inline ::message::Parkspace_release_response_msg* Node_log::mutable_release_response() {
  if (!has_release_response()) {
    clear_response();
    set_has_release_response();
    response_.release_response_ = CreateMaybeMessage< ::message::Parkspace_release_response_msg >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:message.Node_log.release_response)
  return response_.release_response_;
}

// optional .message.Parkspace_confirm_alloc_response_msg confirm_response = 8;
inline bool Node_log::has_confirm_response() const {
  return response_case() == kConfirmResponse;
}
inline void Node_log::set_has_confirm_response() {
  _oneof_case_[1] = kConfirmResponse;
}
inline const ::message::Parkspace_confirm_alloc_response_msg& Node_log::_internal_confirm_response() const {
  return *response_.confirm_response_;
}
inline ::message::Parkspace_confirm_alloc_response_msg* Node_log::release_confirm_response() {
  // @@protoc_insertion_point(field_release:message.Node_log.confirm_response)
  if (has_confirm_response()) {
    clear_has_response();
      ::message::Parkspace_confirm_alloc_response_msg* temp = response_.confirm_response_;
    response_.confirm_response_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::message::Parkspace_confirm_alloc_response_msg& Node_log::confirm_response() const {
  // @@protoc_insertion_point(field_get:message.Node_log.confirm_response)
  return has_confirm_response()
      ? *response_.confirm_response_
      : *reinterpret_cast< ::message::Parkspace_confirm_alloc_response_msg*>(&::message::_Parkspace_confirm_alloc_response_msg_default_instance_);
}
inline ::message::Parkspace_confirm_alloc_response_msg* Node_log::mutable_confirm_response() {
  if (!has_confirm_response()) {
    clear_response();
    set_has_confirm_response();
    response_.confirm_response_ = CreateMaybeMessage< ::message::Parkspace_confirm_alloc_response_msg >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:message.Node_log.confirm_response)
  return response_.confirm_response_;
}

// optional .message.Measure_response_msg measure_response = 10;
inline bool Node_log::has_measure_response() const {
  return response_case() == kMeasureResponse;
}
inline void Node_log::set_has_measure_response() {
  _oneof_case_[1] = kMeasureResponse;
}
inline const ::message::Measure_response_msg& Node_log::_internal_measure_response() const {
  return *response_.measure_response_;
}
inline ::message::Measure_response_msg* Node_log::release_measure_response() {
  // @@protoc_insertion_point(field_release:message.Node_log.measure_response)
  if (has_measure_response()) {
    clear_has_response();
      ::message::Measure_response_msg* temp = response_.measure_response_;
    response_.measure_response_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::message::Measure_response_msg& Node_log::measure_response() const {
  // @@protoc_insertion_point(field_get:message.Node_log.measure_response)
  return has_measure_response()
      ? *response_.measure_response_
      : *reinterpret_cast< ::message::Measure_response_msg*>(&::message::_Measure_response_msg_default_instance_);
}
inline ::message::Measure_response_msg* Node_log::mutable_measure_response() {
  if (!has_measure_response()) {
    clear_response();
    set_has_measure_response();
    response_.measure_response_ = CreateMaybeMessage< ::message::Measure_response_msg >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:message.Node_log.measure_response)
  return response_.measure_response_;
}

// optional .message.Dispatch_response_msg dispatch_response = 12;
inline bool Node_log::has_dispatch_response() const {
  return response_case() == kDispatchResponse;
}
inline void Node_log::set_has_dispatch_response() {
  _oneof_case_[1] = kDispatchResponse;
}
inline const ::message::Dispatch_response_msg& Node_log::_internal_dispatch_response() const {
  return *response_.dispatch_response_;
}
inline ::message::Dispatch_response_msg* Node_log::release_dispatch_response() {
  // @@protoc_insertion_point(field_release:message.Node_log.dispatch_response)
  if (has_dispatch_response()) {
    clear_has_response();
      ::message::Dispatch_response_msg* temp = response_.dispatch_response_;
    response_.dispatch_response_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::message::Dispatch_response_msg& Node_log::dispatch_response() const {
  // @@protoc_insertion_point(field_get:message.Node_log.dispatch_response)
  return has_dispatch_response()
      ? *response_.dispatch_response_
      : *reinterpret_cast< ::message::Dispatch_response_msg*>(&::message::_Dispatch_response_msg_default_instance_);
}
inline ::message::Dispatch_response_msg* Node_log::mutable_dispatch_response() {
  if (!has_dispatch_response()) {
    clear_response();
    set_has_dispatch_response();
    response_.dispatch_response_ = CreateMaybeMessage< ::message::Dispatch_response_msg >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:message.Node_log.dispatch_response)
  return response_.dispatch_response_;
}

// optional string description = 13;
inline bool Node_log::has_description() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void Node_log::set_has_description() {
  _has_bits_[0] |= 0x00000001u;
}
inline void Node_log::clear_has_description() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void Node_log::clear_description() {
  description_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_description();
}
inline const ::std::string& Node_log::description() const {
  // @@protoc_insertion_point(field_get:message.Node_log.description)
  return description_.GetNoArena();
}
inline void Node_log::set_description(const ::std::string& value) {
  set_has_description();
  description_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:message.Node_log.description)
}
#if LANG_CXX11
inline void Node_log::set_description(::std::string&& value) {
  set_has_description();
  description_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:message.Node_log.description)
}
#endif
inline void Node_log::set_description(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_description();
  description_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:message.Node_log.description)
}
inline void Node_log::set_description(const char* value, size_t size) {
  set_has_description();
  description_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:message.Node_log.description)
}
inline ::std::string* Node_log::mutable_description() {
  set_has_description();
  // @@protoc_insertion_point(field_mutable:message.Node_log.description)
  return description_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* Node_log::release_description() {
  // @@protoc_insertion_point(field_release:message.Node_log.description)
  if (!has_description()) {
    return NULL;
  }
  clear_has_description();
  return description_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void Node_log::set_allocated_description(::std::string* description) {
  if (description != NULL) {
    set_has_description();
  } else {
    clear_has_description();
  }
  description_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), description);
  // @@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::has_manual_operation() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void Manual_operation_log::set_has_manual_operation() {
  _has_bits_[0] |= 0x00000002u;
}
inline void Manual_operation_log::clear_has_manual_operation() {
  _has_bits_[0] &= ~0x00000002u;
}
inline const ::message::Process_manual_operation_msg& Manual_operation_log::_internal_manual_operation() const {
  return *manual_operation_;
}
inline const ::message::Process_manual_operation_msg& Manual_operation_log::manual_operation() const {
  const ::message::Process_manual_operation_msg* p = manual_operation_;
  // @@protoc_insertion_point(field_get:message.Manual_operation_log.manual_operation)
  return p != NULL ? *p : *reinterpret_cast<const ::message::Process_manual_operation_msg*>(
      &::message::_Process_manual_operation_msg_default_instance_);
}
inline ::message::Process_manual_operation_msg* Manual_operation_log::release_manual_operation() {
  // @@protoc_insertion_point(field_release:message.Manual_operation_log.manual_operation)
  clear_has_manual_operation();
  ::message::Process_manual_operation_msg* temp = manual_operation_;
  manual_operation_ = NULL;
  return temp;
}
inline ::message::Process_manual_operation_msg* Manual_operation_log::mutable_manual_operation() {
  set_has_manual_operation();
  if (manual_operation_ == NULL) {
    auto* p = CreateMaybeMessage<::message::Process_manual_operation_msg>(GetArenaNoVirtual());
    manual_operation_ = p;
  }
  // @@protoc_insertion_point(field_mutable:message.Manual_operation_log.manual_operation)
  return manual_operation_;
}
inline void Manual_operation_log::set_allocated_manual_operation(::message::Process_manual_operation_msg* manual_operation) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete reinterpret_cast< ::google::protobuf::MessageLite*>(manual_operation_);
  }
  if (manual_operation) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      manual_operation = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, manual_operation, submessage_arena);
    }
    set_has_manual_operation();
  } else {
    clear_has_manual_operation();
  }
  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::has_description() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void Manual_operation_log::set_has_description() {
  _has_bits_[0] |= 0x00000001u;
}
inline void Manual_operation_log::clear_has_description() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void Manual_operation_log::clear_description() {
  description_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_description();
}
inline const ::std::string& Manual_operation_log::description() const {
  // @@protoc_insertion_point(field_get:message.Manual_operation_log.description)
  return description_.GetNoArena();
}
inline void Manual_operation_log::set_description(const ::std::string& value) {
  set_has_description();
  description_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:message.Manual_operation_log.description)
}
#if LANG_CXX11
inline void Manual_operation_log::set_description(::std::string&& value) {
  set_has_description();
  description_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:message.Manual_operation_log.description)
}
#endif
inline void Manual_operation_log::set_description(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_description();
  description_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:message.Manual_operation_log.description)
}
inline void Manual_operation_log::set_description(const char* value, size_t size) {
  set_has_description();
  description_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:message.Manual_operation_log.description)
}
inline ::std::string* Manual_operation_log::mutable_description() {
  set_has_description();
  // @@protoc_insertion_point(field_mutable:message.Manual_operation_log.description)
  return description_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* Manual_operation_log::release_description() {
  // @@protoc_insertion_point(field_release:message.Manual_operation_log.description)
  if (!has_description()) {
    return NULL;
  }
  clear_has_description();
  return description_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void Manual_operation_log::set_allocated_description(::std::string* description) {
  if (description != NULL) {
    set_has_description();
  } else {
    clear_has_description();
  }
  description_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), description);
  // @@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::has_log_severity() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void Log_data::set_has_log_severity() {
  _has_bits_[0] |= 0x00000001u;
}
inline void Log_data::clear_has_log_severity() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void Log_data::clear_log_severity() {
  log_severity_ = 0;
  clear_has_log_severity();
}
inline ::message::Log_data_Severity Log_data::log_severity() const {
  // @@protoc_insertion_point(field_get:message.Log_data.log_severity)
  return static_cast< ::message::Log_data_Severity >(log_severity_);
}
inline void Log_data::set_log_severity(::message::Log_data_Severity value) {
  assert(::message::Log_data_Severity_IsValid(value));
  set_has_log_severity();
  log_severity_ = value;
  // @@protoc_insertion_point(field_set:message.Log_data.log_severity)
}

// optional string str_log = 2;
inline bool Log_data::has_str_log() const {
  return data_case() == kStrLog;
}
inline void Log_data::set_has_str_log() {
  _oneof_case_[0] = kStrLog;
}
inline void Log_data::clear_str_log() {
  if (has_str_log()) {
    data_.str_log_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    clear_has_data();
  }
}
inline const ::std::string& Log_data::str_log() const {
  // @@protoc_insertion_point(field_get:message.Log_data.str_log)
  if (has_str_log()) {
    return data_.str_log_.GetNoArena();
  }
  return *&::google::protobuf::internal::GetEmptyStringAlreadyInited();
}
inline void Log_data::set_str_log(const ::std::string& value) {
  // @@protoc_insertion_point(field_set:message.Log_data.str_log)
  if (!has_str_log()) {
    clear_data();
    set_has_str_log();
    data_.str_log_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  data_.str_log_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:message.Log_data.str_log)
}
#if LANG_CXX11
inline void Log_data::set_str_log(::std::string&& value) {
  // @@protoc_insertion_point(field_set:message.Log_data.str_log)
  if (!has_str_log()) {
    clear_data();
    set_has_str_log();
    data_.str_log_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  data_.str_log_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:message.Log_data.str_log)
}
#endif
inline void Log_data::set_str_log(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  if (!has_str_log()) {
    clear_data();
    set_has_str_log();
    data_.str_log_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  data_.str_log_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(value));
  // @@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 (!has_str_log()) {
    clear_data();
    set_has_str_log();
    data_.str_log_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  data_.str_log_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:message.Log_data.str_log)
}
inline ::std::string* Log_data::mutable_str_log() {
  if (!has_str_log()) {
    clear_data();
    set_has_str_log();
    data_.str_log_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  // @@protoc_insertion_point(field_mutable:message.Log_data.str_log)
  return data_.str_log_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* Log_data::release_str_log() {
  // @@protoc_insertion_point(field_release:message.Log_data.str_log)
  if (has_str_log()) {
    clear_has_data();
    return data_.str_log_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  } else {
    return NULL;
  }
}
inline void Log_data::set_allocated_str_log(::std::string* str_log) {
  if (!has_str_log()) {
    data_.str_log_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  clear_data();
  if (str_log != NULL) {
    set_has_str_log();
    data_.str_log_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), str_log);
  }
  // @@protoc_insertion_point(field_set_allocated:message.Log_data.str_log)
}

// optional .message.Node_log node_log = 3;
inline bool Log_data::has_node_log() const {
  return data_case() == kNodeLog;
}
inline void Log_data::set_has_node_log() {
  _oneof_case_[0] = kNodeLog;
}
inline void Log_data::clear_node_log() {
  if (has_node_log()) {
    delete data_.node_log_;
    clear_has_data();
  }
}
inline const ::message::Node_log& Log_data::_internal_node_log() const {
  return *data_.node_log_;
}
inline ::message::Node_log* Log_data::release_node_log() {
  // @@protoc_insertion_point(field_release:message.Log_data.node_log)
  if (has_node_log()) {
    clear_has_data();
      ::message::Node_log* temp = data_.node_log_;
    data_.node_log_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::message::Node_log& Log_data::node_log() const {
  // @@protoc_insertion_point(field_get:message.Log_data.node_log)
  return has_node_log()
      ? *data_.node_log_
      : *reinterpret_cast< ::message::Node_log*>(&::message::_Node_log_default_instance_);
}
inline ::message::Node_log* Log_data::mutable_node_log() {
  if (!has_node_log()) {
    clear_data();
    set_has_node_log();
    data_.node_log_ = CreateMaybeMessage< ::message::Node_log >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:message.Log_data.node_log)
  return data_.node_log_;
}

// optional .message.Manual_operation_log manual_operator_log = 4;
inline bool Log_data::has_manual_operator_log() const {
  return data_case() == kManualOperatorLog;
}
inline void Log_data::set_has_manual_operator_log() {
  _oneof_case_[0] = kManualOperatorLog;
}
inline void Log_data::clear_manual_operator_log() {
  if (has_manual_operator_log()) {
    delete data_.manual_operator_log_;
    clear_has_data();
  }
}
inline const ::message::Manual_operation_log& Log_data::_internal_manual_operator_log() const {
  return *data_.manual_operator_log_;
}
inline ::message::Manual_operation_log* Log_data::release_manual_operator_log() {
  // @@protoc_insertion_point(field_release:message.Log_data.manual_operator_log)
  if (has_manual_operator_log()) {
    clear_has_data();
      ::message::Manual_operation_log* temp = data_.manual_operator_log_;
    data_.manual_operator_log_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::message::Manual_operation_log& Log_data::manual_operator_log() const {
  // @@protoc_insertion_point(field_get:message.Log_data.manual_operator_log)
  return has_manual_operator_log()
      ? *data_.manual_operator_log_
      : *reinterpret_cast< ::message::Manual_operation_log*>(&::message::_Manual_operation_log_default_instance_);
}
inline ::message::Manual_operation_log* Log_data::mutable_manual_operator_log() {
  if (!has_manual_operator_log()) {
    clear_data();
    set_has_manual_operator_log();
    data_.manual_operator_log_ = CreateMaybeMessage< ::message::Manual_operation_log >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:message.Log_data.manual_operator_log)
  return data_.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::has_process_type() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void Process_log::set_has_process_type() {
  _has_bits_[0] |= 0x00000001u;
}
inline void Process_log::clear_has_process_type() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void Process_log::clear_process_type() {
  process_type_ = 1;
  clear_has_process_type();
}
inline ::message::Process_type Process_log::process_type() const {
  // @@protoc_insertion_point(field_get:message.Process_log.process_type)
  return static_cast< ::message::Process_type >(process_type_);
}
inline void Process_log::set_process_type(::message::Process_type value) {
  assert(::message::Process_type_IsValid(value));
  set_has_process_type();
  process_type_ = value;
  // @@protoc_insertion_point(field_set:message.Process_log.process_type)
}

// repeated .message.Log_data log_data = 2;
inline int Process_log::log_data_size() const {
  return 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 ::google::protobuf::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::log_data(int index) const {
  // @@protoc_insertion_point(field_get:message.Process_log.log_data)
  return log_data_.Get(index);
}
inline ::message::Log_data* Process_log::add_log_data() {
  // @@protoc_insertion_point(field_add:message.Process_log.log_data)
  return log_data_.Add();
}
inline const ::google::protobuf::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

namespace google {
namespace protobuf {

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();
}

}  // namespace protobuf
}  // namespace google

// @@protoc_insertion_point(global_scope)

#endif  // PROTOBUF_INCLUDED_log_5fprocess_2eproto