HM-SPMS/product/src/idl_files/LinkageMessage.pb.cc

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

#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
#include "LinkageMessage.pb.h"

#include <algorithm>

#include <google/protobuf/stubs/common.h>
#include <google/protobuf/stubs/once.h>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/wire_format_lite_inl.h>
#include <google/protobuf/descriptor.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/reflection_ops.h>
#include <google/protobuf/wire_format.h>
// @@protoc_insertion_point(includes)

namespace iot_idl {
namespace linkage {

namespace {

const ::google::protobuf::Descriptor* LcsPkgHead_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  LcsPkgHead_reflection_ = NULL;
const ::google::protobuf::Descriptor* ErrorParameter_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  ErrorParameter_reflection_ = NULL;
const ::google::protobuf::Descriptor* ExecuteStatusParameter_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  ExecuteStatusParameter_reflection_ = NULL;
const ::google::protobuf::Descriptor* ActionNodeStatusParameter_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  ActionNodeStatusParameter_reflection_ = NULL;
const ::google::protobuf::Descriptor* FucNodeStatusParameter_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  FucNodeStatusParameter_reflection_ = NULL;
const ::google::protobuf::Descriptor* LinkNodeStatusParameter_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  LinkNodeStatusParameter_reflection_ = NULL;
const ::google::protobuf::Descriptor* ActorParameter_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  ActorParameter_reflection_ = NULL;
const ::google::protobuf::Descriptor* StatusChangeMessage_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  StatusChangeMessage_reflection_ = NULL;
const ::google::protobuf::Descriptor* LinkStartRequestMessage_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  LinkStartRequestMessage_reflection_ = NULL;
const ::google::protobuf::Descriptor* UiRequestMessage_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  UiRequestMessage_reflection_ = NULL;
const ::google::protobuf::Descriptor* UiRequestMessageAck_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  UiRequestMessageAck_reflection_ = NULL;
const ::google::protobuf::Descriptor* LinkOperateMessage_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  LinkOperateMessage_reflection_ = NULL;
const ::google::protobuf::Descriptor* LinkOperateMessageAck_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  LinkOperateMessageAck_reflection_ = NULL;
const ::google::protobuf::Descriptor* PushParameter_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  PushParameter_reflection_ = NULL;
const ::google::protobuf::Descriptor* HintParameter_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  HintParameter_reflection_ = NULL;
const ::google::protobuf::Descriptor* ActionToHmiMessage_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  ActionToHmiMessage_reflection_ = NULL;
const ::google::protobuf::EnumDescriptor* enChannelMsgType_descriptor_ = NULL;
const ::google::protobuf::EnumDescriptor* enLcsMsgType_descriptor_ = NULL;
const ::google::protobuf::EnumDescriptor* enErrorCode_descriptor_ = NULL;
const ::google::protobuf::EnumDescriptor* ENLcsStatus_descriptor_ = NULL;
const ::google::protobuf::EnumDescriptor* ENLcsNodeCheckStatus_descriptor_ = NULL;
const ::google::protobuf::EnumDescriptor* ENUiOperateType_descriptor_ = NULL;
const ::google::protobuf::EnumDescriptor* ENLinkOperateType_descriptor_ = NULL;
const ::google::protobuf::EnumDescriptor* ENActionOperateType_descriptor_ = NULL;

}  // namespace


void protobuf_AssignDesc_LinkageMessage_2eproto() {
  protobuf_AddDesc_LinkageMessage_2eproto();
  const ::google::protobuf::FileDescriptor* file =
    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
      "LinkageMessage.proto");
  GOOGLE_CHECK(file != NULL);
  LcsPkgHead_descriptor_ = file->message_type(0);
  static const int LcsPkgHead_offsets_[6] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LcsPkgHead, source_tag_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LcsPkgHead, msg_type_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LcsPkgHead, source_domain_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LcsPkgHead, target_domain_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LcsPkgHead, para1_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LcsPkgHead, para2_),
  };
  LcsPkgHead_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      LcsPkgHead_descriptor_,
      LcsPkgHead::default_instance_,
      LcsPkgHead_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LcsPkgHead, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LcsPkgHead, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(LcsPkgHead));
  ErrorParameter_descriptor_ = file->message_type(1);
  static const int ErrorParameter_offsets_[2] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ErrorParameter, errorcode_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ErrorParameter, errordescription_),
  };
  ErrorParameter_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      ErrorParameter_descriptor_,
      ErrorParameter::default_instance_,
      ErrorParameter_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ErrorParameter, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ErrorParameter, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(ErrorParameter));
  ExecuteStatusParameter_descriptor_ = file->message_type(2);
  static const int ExecuteStatusParameter_offsets_[2] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ExecuteStatusParameter, statuscode_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ExecuteStatusParameter, erro_param_),
  };
  ExecuteStatusParameter_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      ExecuteStatusParameter_descriptor_,
      ExecuteStatusParameter::default_instance_,
      ExecuteStatusParameter_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ExecuteStatusParameter, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ExecuteStatusParameter, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(ExecuteStatusParameter));
  ActionNodeStatusParameter_descriptor_ = file->message_type(3);
  static const int ActionNodeStatusParameter_offsets_[5] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ActionNodeStatusParameter, action_name_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ActionNodeStatusParameter, action_desc_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ActionNodeStatusParameter, check_state_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ActionNodeStatusParameter, node_state_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ActionNodeStatusParameter, timeflag_),
  };
  ActionNodeStatusParameter_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      ActionNodeStatusParameter_descriptor_,
      ActionNodeStatusParameter::default_instance_,
      ActionNodeStatusParameter_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ActionNodeStatusParameter, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ActionNodeStatusParameter, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(ActionNodeStatusParameter));
  FucNodeStatusParameter_descriptor_ = file->message_type(4);
  static const int FucNodeStatusParameter_offsets_[6] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FucNodeStatusParameter, fuc_name_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FucNodeStatusParameter, fuc_desc_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FucNodeStatusParameter, check_state_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FucNodeStatusParameter, timeflag_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FucNodeStatusParameter, node_state_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FucNodeStatusParameter, nodelist_),
  };
  FucNodeStatusParameter_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      FucNodeStatusParameter_descriptor_,
      FucNodeStatusParameter::default_instance_,
      FucNodeStatusParameter_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FucNodeStatusParameter, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FucNodeStatusParameter, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(FucNodeStatusParameter));
  LinkNodeStatusParameter_descriptor_ = file->message_type(5);
  static const int LinkNodeStatusParameter_offsets_[6] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LinkNodeStatusParameter, link_name_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LinkNodeStatusParameter, link_desc_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LinkNodeStatusParameter, check_state_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LinkNodeStatusParameter, timeflag_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LinkNodeStatusParameter, node_state_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LinkNodeStatusParameter, nodelist_),
  };
  LinkNodeStatusParameter_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      LinkNodeStatusParameter_descriptor_,
      LinkNodeStatusParameter::default_instance_,
      LinkNodeStatusParameter_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LinkNodeStatusParameter, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LinkNodeStatusParameter, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(LinkNodeStatusParameter));
  ActorParameter_descriptor_ = file->message_type(6);
  static const int ActorParameter_offsets_[4] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ActorParameter, user_id_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ActorParameter, user_groupid_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ActorParameter, host_name_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ActorParameter, user_name_),
  };
  ActorParameter_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      ActorParameter_descriptor_,
      ActorParameter::default_instance_,
      ActorParameter_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ActorParameter, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ActorParameter, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(ActorParameter));
  StatusChangeMessage_descriptor_ = file->message_type(7);
  static const int StatusChangeMessage_offsets_[3] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StatusChangeMessage, pkg_head_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StatusChangeMessage, nodelist_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StatusChangeMessage, execute_status_),
  };
  StatusChangeMessage_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      StatusChangeMessage_descriptor_,
      StatusChangeMessage::default_instance_,
      StatusChangeMessage_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StatusChangeMessage, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StatusChangeMessage, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(StatusChangeMessage));
  LinkStartRequestMessage_descriptor_ = file->message_type(8);
  static const int LinkStartRequestMessage_offsets_[3] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LinkStartRequestMessage, pkg_head_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LinkStartRequestMessage, nodelist_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LinkStartRequestMessage, trigger_time_),
  };
  LinkStartRequestMessage_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      LinkStartRequestMessage_descriptor_,
      LinkStartRequestMessage::default_instance_,
      LinkStartRequestMessage_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LinkStartRequestMessage, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LinkStartRequestMessage, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(LinkStartRequestMessage));
  UiRequestMessage_descriptor_ = file->message_type(9);
  static const int UiRequestMessage_offsets_[4] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UiRequestMessage, pkg_head_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UiRequestMessage, actor_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UiRequestMessage, nodelist_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UiRequestMessage, execute_status_),
  };
  UiRequestMessage_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      UiRequestMessage_descriptor_,
      UiRequestMessage::default_instance_,
      UiRequestMessage_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UiRequestMessage, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UiRequestMessage, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(UiRequestMessage));
  UiRequestMessageAck_descriptor_ = file->message_type(10);
  static const int UiRequestMessageAck_offsets_[4] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UiRequestMessageAck, pkg_head_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UiRequestMessageAck, actor_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UiRequestMessageAck, nodelist_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UiRequestMessageAck, optype_),
  };
  UiRequestMessageAck_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      UiRequestMessageAck_descriptor_,
      UiRequestMessageAck::default_instance_,
      UiRequestMessageAck_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UiRequestMessageAck, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UiRequestMessageAck, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(UiRequestMessageAck));
  LinkOperateMessage_descriptor_ = file->message_type(11);
  static const int LinkOperateMessage_offsets_[4] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LinkOperateMessage, pkg_head_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LinkOperateMessage, link_node_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LinkOperateMessage, actor_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LinkOperateMessage, opreate_type_),
  };
  LinkOperateMessage_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      LinkOperateMessage_descriptor_,
      LinkOperateMessage::default_instance_,
      LinkOperateMessage_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LinkOperateMessage, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LinkOperateMessage, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(LinkOperateMessage));
  LinkOperateMessageAck_descriptor_ = file->message_type(12);
  static const int LinkOperateMessageAck_offsets_[5] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LinkOperateMessageAck, pkg_head_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LinkOperateMessageAck, link_node_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LinkOperateMessageAck, opreate_type_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LinkOperateMessageAck, actor_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LinkOperateMessageAck, execute_status_),
  };
  LinkOperateMessageAck_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      LinkOperateMessageAck_descriptor_,
      LinkOperateMessageAck::default_instance_,
      LinkOperateMessageAck_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LinkOperateMessageAck, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LinkOperateMessageAck, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(LinkOperateMessageAck));
  PushParameter_descriptor_ = file->message_type(13);
  static const int PushParameter_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PushParameter, graph_name_),
  };
  PushParameter_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      PushParameter_descriptor_,
      PushParameter::default_instance_,
      PushParameter_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PushParameter, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PushParameter, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(PushParameter));
  HintParameter_descriptor_ = file->message_type(14);
  static const int HintParameter_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(HintParameter, hint_info_),
  };
  HintParameter_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      HintParameter_descriptor_,
      HintParameter::default_instance_,
      HintParameter_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(HintParameter, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(HintParameter, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(HintParameter));
  ActionToHmiMessage_descriptor_ = file->message_type(15);
  static const int ActionToHmiMessage_offsets_[5] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ActionToHmiMessage, pkg_head_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ActionToHmiMessage, action_type_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ActionToHmiMessage, host_name_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ActionToHmiMessage, push_param_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ActionToHmiMessage, hint_param_),
  };
  ActionToHmiMessage_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      ActionToHmiMessage_descriptor_,
      ActionToHmiMessage::default_instance_,
      ActionToHmiMessage_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ActionToHmiMessage, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ActionToHmiMessage, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(ActionToHmiMessage));
  enChannelMsgType_descriptor_ = file->enum_type(0);
  enLcsMsgType_descriptor_ = file->enum_type(1);
  enErrorCode_descriptor_ = file->enum_type(2);
  ENLcsStatus_descriptor_ = file->enum_type(3);
  ENLcsNodeCheckStatus_descriptor_ = file->enum_type(4);
  ENUiOperateType_descriptor_ = file->enum_type(5);
  ENLinkOperateType_descriptor_ = file->enum_type(6);
  ENActionOperateType_descriptor_ = file->enum_type(7);
}

namespace {

GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
inline void protobuf_AssignDescriptorsOnce() {
  ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
                 &protobuf_AssignDesc_LinkageMessage_2eproto);
}

void protobuf_RegisterTypes(const ::std::string&) {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    LcsPkgHead_descriptor_, &LcsPkgHead::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    ErrorParameter_descriptor_, &ErrorParameter::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    ExecuteStatusParameter_descriptor_, &ExecuteStatusParameter::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    ActionNodeStatusParameter_descriptor_, &ActionNodeStatusParameter::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    FucNodeStatusParameter_descriptor_, &FucNodeStatusParameter::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    LinkNodeStatusParameter_descriptor_, &LinkNodeStatusParameter::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    ActorParameter_descriptor_, &ActorParameter::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    StatusChangeMessage_descriptor_, &StatusChangeMessage::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    LinkStartRequestMessage_descriptor_, &LinkStartRequestMessage::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    UiRequestMessage_descriptor_, &UiRequestMessage::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    UiRequestMessageAck_descriptor_, &UiRequestMessageAck::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    LinkOperateMessage_descriptor_, &LinkOperateMessage::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    LinkOperateMessageAck_descriptor_, &LinkOperateMessageAck::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    PushParameter_descriptor_, &PushParameter::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    HintParameter_descriptor_, &HintParameter::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    ActionToHmiMessage_descriptor_, &ActionToHmiMessage::default_instance());
}

}  // namespace

void protobuf_ShutdownFile_LinkageMessage_2eproto() {
  delete LcsPkgHead::default_instance_;
  delete LcsPkgHead_reflection_;
  delete ErrorParameter::default_instance_;
  delete ErrorParameter_reflection_;
  delete ExecuteStatusParameter::default_instance_;
  delete ExecuteStatusParameter_reflection_;
  delete ActionNodeStatusParameter::default_instance_;
  delete ActionNodeStatusParameter_reflection_;
  delete FucNodeStatusParameter::default_instance_;
  delete FucNodeStatusParameter_reflection_;
  delete LinkNodeStatusParameter::default_instance_;
  delete LinkNodeStatusParameter_reflection_;
  delete ActorParameter::default_instance_;
  delete ActorParameter_reflection_;
  delete StatusChangeMessage::default_instance_;
  delete StatusChangeMessage_reflection_;
  delete LinkStartRequestMessage::default_instance_;
  delete LinkStartRequestMessage_reflection_;
  delete UiRequestMessage::default_instance_;
  delete UiRequestMessage_reflection_;
  delete UiRequestMessageAck::default_instance_;
  delete UiRequestMessageAck_reflection_;
  delete LinkOperateMessage::default_instance_;
  delete LinkOperateMessage_reflection_;
  delete LinkOperateMessageAck::default_instance_;
  delete LinkOperateMessageAck_reflection_;
  delete PushParameter::default_instance_;
  delete PushParameter_reflection_;
  delete HintParameter::default_instance_;
  delete HintParameter_reflection_;
  delete ActionToHmiMessage::default_instance_;
  delete ActionToHmiMessage_reflection_;
}

void protobuf_AddDesc_LinkageMessage_2eproto() {
  static bool already_here = false;
  if (already_here) return;
  already_here = true;
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
    "\n\024LinkageMessage.proto\022\017iot_idl.linkage\""
    "\235\001\n\nLcsPkgHead\022\022\n\nsource_tag\030\001 \002(\t\022/\n\010ms"
    "g_type\030\002 \002(\0162\035.iot_idl.linkage.enLcsMsgT"
    "ype\022\025\n\rsource_domain\030\003 \002(\005\022\025\n\rtarget_dom"
    "ain\030\004 \002(\005\022\r\n\005para1\030\005 \002(\005\022\r\n\005para2\030\006 \002(\005\""
    "[\n\016ErrorParameter\022/\n\tErrorCode\030\001 \002(\0162\034.i"
    "ot_idl.linkage.enErrorCode\022\030\n\020ErrorDescr"
    "iption\030\002 \002(\t\"a\n\026ExecuteStatusParameter\022\022"
    "\n\nStatusCode\030\001 \002(\005\0223\n\nerro_param\030\002 \001(\0132\037"
    ".iot_idl.linkage.ErrorParameter\"\305\001\n\031Acti"
    "onNodeStatusParameter\022\023\n\013action_name\030\001 \002"
    "(\t\022\023\n\013action_desc\030\002 \002(\t\022:\n\013check_state\030\003"
    " \002(\0162%.iot_idl.linkage.ENLcsNodeCheckSta"
    "tus\0220\n\nnode_state\030\004 \002(\0162\034.iot_idl.linkag"
    "e.ENLcsStatus\022\020\n\010timeflag\030\005 \002(\003\"\372\001\n\026FucN"
    "odeStatusParameter\022\020\n\010fuc_name\030\001 \002(\t\022\020\n\010"
    "fuc_desc\030\002 \002(\t\022:\n\013check_state\030\003 \002(\0162%.io"
    "t_idl.linkage.ENLcsNodeCheckStatus\022\020\n\010ti"
    "meflag\030\004 \002(\003\0220\n\nnode_state\030\005 \002(\0162\034.iot_i"
    "dl.linkage.ENLcsStatus\022<\n\010nodelist\030\006 \003(\013"
    "2*.iot_idl.linkage.ActionNodeStatusParam"
    "eter\"\372\001\n\027LinkNodeStatusParameter\022\021\n\tlink"
    "_name\030\001 \002(\t\022\021\n\tlink_desc\030\002 \002(\t\022:\n\013check_"
    "state\030\003 \002(\0162%.iot_idl.linkage.ENLcsNodeC"
    "heckStatus\022\020\n\010timeflag\030\004 \002(\003\0220\n\nnode_sta"
    "te\030\005 \002(\0162\034.iot_idl.linkage.ENLcsStatus\0229"
    "\n\010nodelist\030\006 \003(\0132\'.iot_idl.linkage.FucNo"
    "deStatusParameter\"]\n\016ActorParameter\022\017\n\007u"
    "ser_id\030\001 \002(\005\022\024\n\014user_groupId\030\002 \002(\005\022\021\n\tho"
    "st_name\030\003 \002(\t\022\021\n\tuser_name\030\004 \002(\t\"\301\001\n\023Sta"
    "tusChangeMessage\022-\n\010pkg_head\030\001 \002(\0132\033.iot"
    "_idl.linkage.LcsPkgHead\022:\n\010nodelist\030\002 \002("
    "\0132(.iot_idl.linkage.LinkNodeStatusParame"
    "ter\022\?\n\016execute_status\030\003 \003(\0132\'.iot_idl.li"
    "nkage.ExecuteStatusParameter\"\232\001\n\027LinkSta"
    "rtRequestMessage\022-\n\010pkg_head\030\001 \002(\0132\033.iot"
    "_idl.linkage.LcsPkgHead\022:\n\010nodelist\030\002 \002("
    "\0132(.iot_idl.linkage.LinkNodeStatusParame"
    "ter\022\024\n\014trigger_time\030\003 \002(\003\"\356\001\n\020UiRequestM"
    "essage\022-\n\010pkg_head\030\001 \002(\0132\033.iot_idl.linka"
    "ge.LcsPkgHead\022.\n\005actor\030\002 \002(\0132\037.iot_idl.l"
    "inkage.ActorParameter\022:\n\010nodelist\030\003 \002(\0132"
    "(.iot_idl.linkage.LinkNodeStatusParamete"
    "r\022\?\n\016execute_status\030\004 \002(\0132\'.iot_idl.link"
    "age.ExecuteStatusParameter\"\342\001\n\023UiRequest"
    "MessageAck\022-\n\010pkg_head\030\001 \002(\0132\033.iot_idl.l"
    "inkage.LcsPkgHead\022.\n\005actor\030\002 \002(\0132\037.iot_i"
    "dl.linkage.ActorParameter\022:\n\010nodelist\030\003 "
    "\002(\0132(.iot_idl.linkage.LinkNodeStatusPara"
    "meter\0220\n\006optype\030\004 \002(\0162 .iot_idl.linkage."
    "ENUiOperateType\"\352\001\n\022LinkOperateMessage\022-"
    "\n\010pkg_head\030\001 \002(\0132\033.iot_idl.linkage.LcsPk"
    "gHead\022;\n\tlink_node\030\002 \002(\0132(.iot_idl.linka"
    "ge.LinkNodeStatusParameter\022.\n\005actor\030\003 \002("
    "\0132\037.iot_idl.linkage.ActorParameter\0228\n\014op"
    "reate_type\030\004 \002(\0162\".iot_idl.linkage.ENLin"
    "kOperateType\"\256\002\n\025LinkOperateMessageAck\022-"
    "\n\010pkg_head\030\001 \002(\0132\033.iot_idl.linkage.LcsPk"
    "gHead\022;\n\tlink_node\030\002 \002(\0132(.iot_idl.linka"
    "ge.LinkNodeStatusParameter\0228\n\014opreate_ty"
    "pe\030\003 \002(\0162\".iot_idl.linkage.ENLinkOperate"
    "Type\022.\n\005actor\030\004 \002(\0132\037.iot_idl.linkage.Ac"
    "torParameter\022\?\n\016execute_status\030\005 \002(\0132\'.i"
    "ot_idl.linkage.ExecuteStatusParameter\"#\n"
    "\rPushParameter\022\022\n\ngraph_name\030\001 \002(\t\"\"\n\rHi"
    "ntParameter\022\021\n\thint_info\030\001 \002(\t\"\371\001\n\022Actio"
    "nToHmiMessage\022-\n\010pkg_head\030\001 \002(\0132\033.iot_id"
    "l.linkage.LcsPkgHead\0229\n\013action_type\030\002 \002("
    "\0162$.iot_idl.linkage.ENActionOperateType\022"
    "\021\n\thost_name\030\003 \002(\t\0222\n\npush_param\030\004 \001(\0132\036"
    ".iot_idl.linkage.PushParameter\0222\n\nhint_p"
    "aram\030\005 \001(\0132\036.iot_idl.linkage.HintParamet"
    "er*f\n\020enChannelMsgType\022\034\n\030MT_LINKAGE_CTR"
    "L_HMI_DOWN\020\002\022\032\n\026MT_LINKAGE_CTRL_HMI_UP\020\003"
    "\022\030\n\024MT_LINKAGE_ACTION_UP\020\004*\324\001\n\014enLcsMsgT"
    "ype\022\025\n\021enumStatusMessage\020\001\022\037\n\033enumLinkSt"
    "artRequestMessage\020\002\022\032\n\026enumLinkOperateMe"
    "ssage\020\003\022\035\n\031enumLinkOperateMessageAck\020\004\022\030"
    "\n\024enumUiRequestMessage\020\005\022\033\n\027enumUiReques"
    "tMessageAck\020\006\022\032\n\026enumActionToHmiMessage\020"
    "\007*\261\002\n\013enErrorCode\022\024\n\020enumCode_SUCCESS\020\000\022"
    "\030\n\024enumCode_ERRO_UNKNOW\020\001\022\036\n\032enumCode_ER"
    "RO_TIMEFLAG_OLD\020\002\022\036\n\032enumCode_ERRO_NOFOU"
    "ND_LINK\020\003\022 \n\034enumCode_ERRO_ACTION_TIMEOU"
    "T\020\004\022 \n\034enumCode_ERRO_ACTION_RECOVER\020\005\022#\n"
    "\037enumCode_ERRO_ACTION_OPT_FAILED\020\006\022#\n\037en"
    "umCode_ERRO_ACTION_UI_TIMEOUT\020\007\022$\n enumC"
    "ode_ERRO_ACTION_SEND_FAILED\020\010*\356\001\n\013ENLcsS"
    "tatus\022\033\n\027enumLINK_RESTING_STATUS\020\000\022\033\n\027en"
    "umLINK_RUNNING_STATUS\020\001\022\035\n\031enumLINK_TRIG"
    "GERED_STATUS\020\002\022\032\n\026enumLINK_FAILED_STATUS"
    "\020\003\022\033\n\027enumLINK_SUCCESS_STATUS\020\004\022\030\n\024enumL"
    "INK_STOP_STATUS\020\005\022\031\n\025enumLINK_PAUSE_STAT"
    "US\020\006\022\030\n\024enumLINK_SKIP_STATUS\020\007*`\n\024ENLcsN"
    "odeCheckStatus\022\025\n\021enumNodeUnChecked\020\000\022\034\n"
    "\030enumnodePartiallyChecked\020\001\022\023\n\017enumNodeC"
    "hecked\020\002*N\n\017ENUiOperateType\022\023\n\017enumUI_OP"
    "_RETRY\020\001\022\022\n\016enumUI_OP_STOP\020\002\022\022\n\016enumUI_O"
    "P_SKIP\020\003*\240\001\n\021ENLinkOperateType\022\025\n\021enumOP"
    "_LINK_START\020\000\022\024\n\020enumOP_LINK_STOP\020\001\022\025\n\021e"
    "numOP_LINK_PAUSE\020\002\022\030\n\024enumOP_LINK_CONTIN"
    "UE\020\003\022\024\n\020enumOP_SES_START\020\004\022\027\n\023enumOP_SES"
    "_CONTINUE\020\005*9\n\023ENActionOperateType\022\020\n\014en"
    "umPushType\020\000\022\020\n\014enumHintType\020\001", 4150);
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
    "LinkageMessage.proto", &protobuf_RegisterTypes);
  LcsPkgHead::default_instance_ = new LcsPkgHead();
  ErrorParameter::default_instance_ = new ErrorParameter();
  ExecuteStatusParameter::default_instance_ = new ExecuteStatusParameter();
  ActionNodeStatusParameter::default_instance_ = new ActionNodeStatusParameter();
  FucNodeStatusParameter::default_instance_ = new FucNodeStatusParameter();
  LinkNodeStatusParameter::default_instance_ = new LinkNodeStatusParameter();
  ActorParameter::default_instance_ = new ActorParameter();
  StatusChangeMessage::default_instance_ = new StatusChangeMessage();
  LinkStartRequestMessage::default_instance_ = new LinkStartRequestMessage();
  UiRequestMessage::default_instance_ = new UiRequestMessage();
  UiRequestMessageAck::default_instance_ = new UiRequestMessageAck();
  LinkOperateMessage::default_instance_ = new LinkOperateMessage();
  LinkOperateMessageAck::default_instance_ = new LinkOperateMessageAck();
  PushParameter::default_instance_ = new PushParameter();
  HintParameter::default_instance_ = new HintParameter();
  ActionToHmiMessage::default_instance_ = new ActionToHmiMessage();
  LcsPkgHead::default_instance_->InitAsDefaultInstance();
  ErrorParameter::default_instance_->InitAsDefaultInstance();
  ExecuteStatusParameter::default_instance_->InitAsDefaultInstance();
  ActionNodeStatusParameter::default_instance_->InitAsDefaultInstance();
  FucNodeStatusParameter::default_instance_->InitAsDefaultInstance();
  LinkNodeStatusParameter::default_instance_->InitAsDefaultInstance();
  ActorParameter::default_instance_->InitAsDefaultInstance();
  StatusChangeMessage::default_instance_->InitAsDefaultInstance();
  LinkStartRequestMessage::default_instance_->InitAsDefaultInstance();
  UiRequestMessage::default_instance_->InitAsDefaultInstance();
  UiRequestMessageAck::default_instance_->InitAsDefaultInstance();
  LinkOperateMessage::default_instance_->InitAsDefaultInstance();
  LinkOperateMessageAck::default_instance_->InitAsDefaultInstance();
  PushParameter::default_instance_->InitAsDefaultInstance();
  HintParameter::default_instance_->InitAsDefaultInstance();
  ActionToHmiMessage::default_instance_->InitAsDefaultInstance();
  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_LinkageMessage_2eproto);
}

// Force AddDescriptors() to be called at static initialization time.
struct StaticDescriptorInitializer_LinkageMessage_2eproto {
  StaticDescriptorInitializer_LinkageMessage_2eproto() {
    protobuf_AddDesc_LinkageMessage_2eproto();
  }
} static_descriptor_initializer_LinkageMessage_2eproto_;
const ::google::protobuf::EnumDescriptor* enChannelMsgType_descriptor() {
  protobuf_AssignDescriptorsOnce();
  return enChannelMsgType_descriptor_;
}
bool enChannelMsgType_IsValid(int value) {
  switch(value) {
    case 2:
    case 3:
    case 4:
      return true;
    default:
      return false;
  }
}

const ::google::protobuf::EnumDescriptor* enLcsMsgType_descriptor() {
  protobuf_AssignDescriptorsOnce();
  return enLcsMsgType_descriptor_;
}
bool enLcsMsgType_IsValid(int value) {
  switch(value) {
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
    case 6:
    case 7:
      return true;
    default:
      return false;
  }
}

const ::google::protobuf::EnumDescriptor* enErrorCode_descriptor() {
  protobuf_AssignDescriptorsOnce();
  return enErrorCode_descriptor_;
}
bool enErrorCode_IsValid(int value) {
  switch(value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
    case 6:
    case 7:
    case 8:
      return true;
    default:
      return false;
  }
}

const ::google::protobuf::EnumDescriptor* ENLcsStatus_descriptor() {
  protobuf_AssignDescriptorsOnce();
  return ENLcsStatus_descriptor_;
}
bool ENLcsStatus_IsValid(int value) {
  switch(value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
    case 6:
    case 7:
      return true;
    default:
      return false;
  }
}

const ::google::protobuf::EnumDescriptor* ENLcsNodeCheckStatus_descriptor() {
  protobuf_AssignDescriptorsOnce();
  return ENLcsNodeCheckStatus_descriptor_;
}
bool ENLcsNodeCheckStatus_IsValid(int value) {
  switch(value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}

const ::google::protobuf::EnumDescriptor* ENUiOperateType_descriptor() {
  protobuf_AssignDescriptorsOnce();
  return ENUiOperateType_descriptor_;
}
bool ENUiOperateType_IsValid(int value) {
  switch(value) {
    case 1:
    case 2:
    case 3:
      return true;
    default:
      return false;
  }
}

const ::google::protobuf::EnumDescriptor* ENLinkOperateType_descriptor() {
  protobuf_AssignDescriptorsOnce();
  return ENLinkOperateType_descriptor_;
}
bool ENLinkOperateType_IsValid(int value) {
  switch(value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
      return true;
    default:
      return false;
  }
}

const ::google::protobuf::EnumDescriptor* ENActionOperateType_descriptor() {
  protobuf_AssignDescriptorsOnce();
  return ENActionOperateType_descriptor_;
}
bool ENActionOperateType_IsValid(int value) {
  switch(value) {
    case 0:
    case 1:
      return true;
    default:
      return false;
  }
}


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

#ifndef _MSC_VER
const int LcsPkgHead::kSourceTagFieldNumber;
const int LcsPkgHead::kMsgTypeFieldNumber;
const int LcsPkgHead::kSourceDomainFieldNumber;
const int LcsPkgHead::kTargetDomainFieldNumber;
const int LcsPkgHead::kPara1FieldNumber;
const int LcsPkgHead::kPara2FieldNumber;
#endif  // !_MSC_VER

LcsPkgHead::LcsPkgHead()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:iot_idl.linkage.LcsPkgHead)
}

void LcsPkgHead::InitAsDefaultInstance() {
}

LcsPkgHead::LcsPkgHead(const LcsPkgHead& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:iot_idl.linkage.LcsPkgHead)
}

void LcsPkgHead::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  source_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  msg_type_ = 1;
  source_domain_ = 0;
  target_domain_ = 0;
  para1_ = 0;
  para2_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

LcsPkgHead::~LcsPkgHead() {
  // @@protoc_insertion_point(destructor:iot_idl.linkage.LcsPkgHead)
  SharedDtor();
}

void LcsPkgHead::SharedDtor() {
  if (source_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete source_tag_;
  }
  if (this != default_instance_) {
  }
}

void LcsPkgHead::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* LcsPkgHead::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return LcsPkgHead_descriptor_;
}

const LcsPkgHead& LcsPkgHead::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_LinkageMessage_2eproto();
  return *default_instance_;
}

LcsPkgHead* LcsPkgHead::default_instance_ = NULL;

LcsPkgHead* LcsPkgHead::New() const {
  return new LcsPkgHead;
}

void LcsPkgHead::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<LcsPkgHead*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  if (_has_bits_[0 / 32] & 63) {
    ZR_(source_domain_, para2_);
    if (has_source_tag()) {
      if (source_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        source_tag_->clear();
      }
    }
    msg_type_ = 1;
  }

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool LcsPkgHead::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:iot_idl.linkage.LcsPkgHead)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required string source_tag = 1;
      case 1: {
        if (tag == 10) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_source_tag()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->source_tag().data(), this->source_tag().length(),
            ::google::protobuf::internal::WireFormat::PARSE,
            "source_tag");
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_msg_type;
        break;
      }

      // required .iot_idl.linkage.enLcsMsgType msg_type = 2;
      case 2: {
        if (tag == 16) {
         parse_msg_type:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::iot_idl::linkage::enLcsMsgType_IsValid(value)) {
            set_msg_type(static_cast< ::iot_idl::linkage::enLcsMsgType >(value));
          } else {
            mutable_unknown_fields()->AddVarint(2, value);
          }
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_source_domain;
        break;
      }

      // required int32 source_domain = 3;
      case 3: {
        if (tag == 24) {
         parse_source_domain:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &source_domain_)));
          set_has_source_domain();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(32)) goto parse_target_domain;
        break;
      }

      // required int32 target_domain = 4;
      case 4: {
        if (tag == 32) {
         parse_target_domain:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &target_domain_)));
          set_has_target_domain();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(40)) goto parse_para1;
        break;
      }

      // required int32 para1 = 5;
      case 5: {
        if (tag == 40) {
         parse_para1:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &para1_)));
          set_has_para1();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(48)) goto parse_para2;
        break;
      }

      // required int32 para2 = 6;
      case 6: {
        if (tag == 48) {
         parse_para2:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &para2_)));
          set_has_para2();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:iot_idl.linkage.LcsPkgHead)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:iot_idl.linkage.LcsPkgHead)
  return false;
#undef DO_
}

void LcsPkgHead::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:iot_idl.linkage.LcsPkgHead)
  // required string source_tag = 1;
  if (has_source_tag()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->source_tag().data(), this->source_tag().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "source_tag");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      1, this->source_tag(), output);
  }

  // required .iot_idl.linkage.enLcsMsgType msg_type = 2;
  if (has_msg_type()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      2, this->msg_type(), output);
  }

  // required int32 source_domain = 3;
  if (has_source_domain()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->source_domain(), output);
  }

  // required int32 target_domain = 4;
  if (has_target_domain()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(4, this->target_domain(), output);
  }

  // required int32 para1 = 5;
  if (has_para1()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(5, this->para1(), output);
  }

  // required int32 para2 = 6;
  if (has_para2()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(6, this->para2(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:iot_idl.linkage.LcsPkgHead)
}

::google::protobuf::uint8* LcsPkgHead::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:iot_idl.linkage.LcsPkgHead)
  // required string source_tag = 1;
  if (has_source_tag()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->source_tag().data(), this->source_tag().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "source_tag");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        1, this->source_tag(), target);
  }

  // required .iot_idl.linkage.enLcsMsgType msg_type = 2;
  if (has_msg_type()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      2, this->msg_type(), target);
  }

  // required int32 source_domain = 3;
  if (has_source_domain()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(3, this->source_domain(), target);
  }

  // required int32 target_domain = 4;
  if (has_target_domain()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(4, this->target_domain(), target);
  }

  // required int32 para1 = 5;
  if (has_para1()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(5, this->para1(), target);
  }

  // required int32 para2 = 6;
  if (has_para2()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(6, this->para2(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:iot_idl.linkage.LcsPkgHead)
  return target;
}

int LcsPkgHead::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required string source_tag = 1;
    if (has_source_tag()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->source_tag());
    }

    // required .iot_idl.linkage.enLcsMsgType msg_type = 2;
    if (has_msg_type()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->msg_type());
    }

    // required int32 source_domain = 3;
    if (has_source_domain()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->source_domain());
    }

    // required int32 target_domain = 4;
    if (has_target_domain()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->target_domain());
    }

    // required int32 para1 = 5;
    if (has_para1()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->para1());
    }

    // required int32 para2 = 6;
    if (has_para2()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->para2());
    }

  }
  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void LcsPkgHead::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const LcsPkgHead* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const LcsPkgHead*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void LcsPkgHead::MergeFrom(const LcsPkgHead& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_source_tag()) {
      set_source_tag(from.source_tag());
    }
    if (from.has_msg_type()) {
      set_msg_type(from.msg_type());
    }
    if (from.has_source_domain()) {
      set_source_domain(from.source_domain());
    }
    if (from.has_target_domain()) {
      set_target_domain(from.target_domain());
    }
    if (from.has_para1()) {
      set_para1(from.para1());
    }
    if (from.has_para2()) {
      set_para2(from.para2());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void LcsPkgHead::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void LcsPkgHead::CopyFrom(const LcsPkgHead& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool LcsPkgHead::IsInitialized() const {
  if ((_has_bits_[0] & 0x0000003f) != 0x0000003f) return false;

  return true;
}

void LcsPkgHead::Swap(LcsPkgHead* other) {
  if (other != this) {
    std::swap(source_tag_, other->source_tag_);
    std::swap(msg_type_, other->msg_type_);
    std::swap(source_domain_, other->source_domain_);
    std::swap(target_domain_, other->target_domain_);
    std::swap(para1_, other->para1_);
    std::swap(para2_, other->para2_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata LcsPkgHead::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = LcsPkgHead_descriptor_;
  metadata.reflection = LcsPkgHead_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int ErrorParameter::kErrorCodeFieldNumber;
const int ErrorParameter::kErrorDescriptionFieldNumber;
#endif  // !_MSC_VER

ErrorParameter::ErrorParameter()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:iot_idl.linkage.ErrorParameter)
}

void ErrorParameter::InitAsDefaultInstance() {
}

ErrorParameter::ErrorParameter(const ErrorParameter& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:iot_idl.linkage.ErrorParameter)
}

void ErrorParameter::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  errorcode_ = 0;
  errordescription_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

ErrorParameter::~ErrorParameter() {
  // @@protoc_insertion_point(destructor:iot_idl.linkage.ErrorParameter)
  SharedDtor();
}

void ErrorParameter::SharedDtor() {
  if (errordescription_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete errordescription_;
  }
  if (this != default_instance_) {
  }
}

void ErrorParameter::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* ErrorParameter::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return ErrorParameter_descriptor_;
}

const ErrorParameter& ErrorParameter::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_LinkageMessage_2eproto();
  return *default_instance_;
}

ErrorParameter* ErrorParameter::default_instance_ = NULL;

ErrorParameter* ErrorParameter::New() const {
  return new ErrorParameter;
}

void ErrorParameter::Clear() {
  if (_has_bits_[0 / 32] & 3) {
    errorcode_ = 0;
    if (has_errordescription()) {
      if (errordescription_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        errordescription_->clear();
      }
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool ErrorParameter::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:iot_idl.linkage.ErrorParameter)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required .iot_idl.linkage.enErrorCode ErrorCode = 1;
      case 1: {
        if (tag == 8) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::iot_idl::linkage::enErrorCode_IsValid(value)) {
            set_errorcode(static_cast< ::iot_idl::linkage::enErrorCode >(value));
          } else {
            mutable_unknown_fields()->AddVarint(1, value);
          }
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_ErrorDescription;
        break;
      }

      // required string ErrorDescription = 2;
      case 2: {
        if (tag == 18) {
         parse_ErrorDescription:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_errordescription()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->errordescription().data(), this->errordescription().length(),
            ::google::protobuf::internal::WireFormat::PARSE,
            "errordescription");
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:iot_idl.linkage.ErrorParameter)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:iot_idl.linkage.ErrorParameter)
  return false;
#undef DO_
}

void ErrorParameter::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:iot_idl.linkage.ErrorParameter)
  // required .iot_idl.linkage.enErrorCode ErrorCode = 1;
  if (has_errorcode()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->errorcode(), output);
  }

  // required string ErrorDescription = 2;
  if (has_errordescription()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->errordescription().data(), this->errordescription().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "errordescription");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      2, this->errordescription(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:iot_idl.linkage.ErrorParameter)
}

::google::protobuf::uint8* ErrorParameter::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:iot_idl.linkage.ErrorParameter)
  // required .iot_idl.linkage.enErrorCode ErrorCode = 1;
  if (has_errorcode()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      1, this->errorcode(), target);
  }

  // required string ErrorDescription = 2;
  if (has_errordescription()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->errordescription().data(), this->errordescription().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "errordescription");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        2, this->errordescription(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:iot_idl.linkage.ErrorParameter)
  return target;
}

int ErrorParameter::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required .iot_idl.linkage.enErrorCode ErrorCode = 1;
    if (has_errorcode()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->errorcode());
    }

    // required string ErrorDescription = 2;
    if (has_errordescription()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->errordescription());
    }

  }
  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void ErrorParameter::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const ErrorParameter* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const ErrorParameter*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void ErrorParameter::MergeFrom(const ErrorParameter& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_errorcode()) {
      set_errorcode(from.errorcode());
    }
    if (from.has_errordescription()) {
      set_errordescription(from.errordescription());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void ErrorParameter::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void ErrorParameter::CopyFrom(const ErrorParameter& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ErrorParameter::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;

  return true;
}

void ErrorParameter::Swap(ErrorParameter* other) {
  if (other != this) {
    std::swap(errorcode_, other->errorcode_);
    std::swap(errordescription_, other->errordescription_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata ErrorParameter::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = ErrorParameter_descriptor_;
  metadata.reflection = ErrorParameter_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int ExecuteStatusParameter::kStatusCodeFieldNumber;
const int ExecuteStatusParameter::kErroParamFieldNumber;
#endif  // !_MSC_VER

ExecuteStatusParameter::ExecuteStatusParameter()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:iot_idl.linkage.ExecuteStatusParameter)
}

void ExecuteStatusParameter::InitAsDefaultInstance() {
  erro_param_ = const_cast< ::iot_idl::linkage::ErrorParameter*>(&::iot_idl::linkage::ErrorParameter::default_instance());
}

ExecuteStatusParameter::ExecuteStatusParameter(const ExecuteStatusParameter& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:iot_idl.linkage.ExecuteStatusParameter)
}

void ExecuteStatusParameter::SharedCtor() {
  _cached_size_ = 0;
  statuscode_ = 0;
  erro_param_ = NULL;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

ExecuteStatusParameter::~ExecuteStatusParameter() {
  // @@protoc_insertion_point(destructor:iot_idl.linkage.ExecuteStatusParameter)
  SharedDtor();
}

void ExecuteStatusParameter::SharedDtor() {
  if (this != default_instance_) {
    delete erro_param_;
  }
}

void ExecuteStatusParameter::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* ExecuteStatusParameter::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return ExecuteStatusParameter_descriptor_;
}

const ExecuteStatusParameter& ExecuteStatusParameter::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_LinkageMessage_2eproto();
  return *default_instance_;
}

ExecuteStatusParameter* ExecuteStatusParameter::default_instance_ = NULL;

ExecuteStatusParameter* ExecuteStatusParameter::New() const {
  return new ExecuteStatusParameter;
}

void ExecuteStatusParameter::Clear() {
  if (_has_bits_[0 / 32] & 3) {
    statuscode_ = 0;
    if (has_erro_param()) {
      if (erro_param_ != NULL) erro_param_->::iot_idl::linkage::ErrorParameter::Clear();
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool ExecuteStatusParameter::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:iot_idl.linkage.ExecuteStatusParameter)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required int32 StatusCode = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &statuscode_)));
          set_has_statuscode();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_erro_param;
        break;
      }

      // optional .iot_idl.linkage.ErrorParameter erro_param = 2;
      case 2: {
        if (tag == 18) {
         parse_erro_param:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_erro_param()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:iot_idl.linkage.ExecuteStatusParameter)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:iot_idl.linkage.ExecuteStatusParameter)
  return false;
#undef DO_
}

void ExecuteStatusParameter::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:iot_idl.linkage.ExecuteStatusParameter)
  // required int32 StatusCode = 1;
  if (has_statuscode()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->statuscode(), output);
  }

  // optional .iot_idl.linkage.ErrorParameter erro_param = 2;
  if (has_erro_param()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      2, this->erro_param(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:iot_idl.linkage.ExecuteStatusParameter)
}

::google::protobuf::uint8* ExecuteStatusParameter::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:iot_idl.linkage.ExecuteStatusParameter)
  // required int32 StatusCode = 1;
  if (has_statuscode()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->statuscode(), target);
  }

  // optional .iot_idl.linkage.ErrorParameter erro_param = 2;
  if (has_erro_param()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        2, this->erro_param(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:iot_idl.linkage.ExecuteStatusParameter)
  return target;
}

int ExecuteStatusParameter::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required int32 StatusCode = 1;
    if (has_statuscode()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->statuscode());
    }

    // optional .iot_idl.linkage.ErrorParameter erro_param = 2;
    if (has_erro_param()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->erro_param());
    }

  }
  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void ExecuteStatusParameter::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const ExecuteStatusParameter* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const ExecuteStatusParameter*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void ExecuteStatusParameter::MergeFrom(const ExecuteStatusParameter& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_statuscode()) {
      set_statuscode(from.statuscode());
    }
    if (from.has_erro_param()) {
      mutable_erro_param()->::iot_idl::linkage::ErrorParameter::MergeFrom(from.erro_param());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void ExecuteStatusParameter::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void ExecuteStatusParameter::CopyFrom(const ExecuteStatusParameter& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ExecuteStatusParameter::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;

  if (has_erro_param()) {
    if (!this->erro_param().IsInitialized()) return false;
  }
  return true;
}

void ExecuteStatusParameter::Swap(ExecuteStatusParameter* other) {
  if (other != this) {
    std::swap(statuscode_, other->statuscode_);
    std::swap(erro_param_, other->erro_param_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata ExecuteStatusParameter::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = ExecuteStatusParameter_descriptor_;
  metadata.reflection = ExecuteStatusParameter_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int ActionNodeStatusParameter::kActionNameFieldNumber;
const int ActionNodeStatusParameter::kActionDescFieldNumber;
const int ActionNodeStatusParameter::kCheckStateFieldNumber;
const int ActionNodeStatusParameter::kNodeStateFieldNumber;
const int ActionNodeStatusParameter::kTimeflagFieldNumber;
#endif  // !_MSC_VER

ActionNodeStatusParameter::ActionNodeStatusParameter()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:iot_idl.linkage.ActionNodeStatusParameter)
}

void ActionNodeStatusParameter::InitAsDefaultInstance() {
}

ActionNodeStatusParameter::ActionNodeStatusParameter(const ActionNodeStatusParameter& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:iot_idl.linkage.ActionNodeStatusParameter)
}

void ActionNodeStatusParameter::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  action_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  action_desc_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  check_state_ = 0;
  node_state_ = 0;
  timeflag_ = GOOGLE_LONGLONG(0);
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

ActionNodeStatusParameter::~ActionNodeStatusParameter() {
  // @@protoc_insertion_point(destructor:iot_idl.linkage.ActionNodeStatusParameter)
  SharedDtor();
}

void ActionNodeStatusParameter::SharedDtor() {
  if (action_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete action_name_;
  }
  if (action_desc_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete action_desc_;
  }
  if (this != default_instance_) {
  }
}

void ActionNodeStatusParameter::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* ActionNodeStatusParameter::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return ActionNodeStatusParameter_descriptor_;
}

const ActionNodeStatusParameter& ActionNodeStatusParameter::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_LinkageMessage_2eproto();
  return *default_instance_;
}

ActionNodeStatusParameter* ActionNodeStatusParameter::default_instance_ = NULL;

ActionNodeStatusParameter* ActionNodeStatusParameter::New() const {
  return new ActionNodeStatusParameter;
}

void ActionNodeStatusParameter::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<ActionNodeStatusParameter*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  if (_has_bits_[0 / 32] & 31) {
    ZR_(check_state_, timeflag_);
    if (has_action_name()) {
      if (action_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        action_name_->clear();
      }
    }
    if (has_action_desc()) {
      if (action_desc_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        action_desc_->clear();
      }
    }
  }

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool ActionNodeStatusParameter::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:iot_idl.linkage.ActionNodeStatusParameter)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required string action_name = 1;
      case 1: {
        if (tag == 10) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_action_name()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->action_name().data(), this->action_name().length(),
            ::google::protobuf::internal::WireFormat::PARSE,
            "action_name");
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_action_desc;
        break;
      }

      // required string action_desc = 2;
      case 2: {
        if (tag == 18) {
         parse_action_desc:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_action_desc()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->action_desc().data(), this->action_desc().length(),
            ::google::protobuf::internal::WireFormat::PARSE,
            "action_desc");
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_check_state;
        break;
      }

      // required .iot_idl.linkage.ENLcsNodeCheckStatus check_state = 3;
      case 3: {
        if (tag == 24) {
         parse_check_state:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::iot_idl::linkage::ENLcsNodeCheckStatus_IsValid(value)) {
            set_check_state(static_cast< ::iot_idl::linkage::ENLcsNodeCheckStatus >(value));
          } else {
            mutable_unknown_fields()->AddVarint(3, value);
          }
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(32)) goto parse_node_state;
        break;
      }

      // required .iot_idl.linkage.ENLcsStatus node_state = 4;
      case 4: {
        if (tag == 32) {
         parse_node_state:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::iot_idl::linkage::ENLcsStatus_IsValid(value)) {
            set_node_state(static_cast< ::iot_idl::linkage::ENLcsStatus >(value));
          } else {
            mutable_unknown_fields()->AddVarint(4, value);
          }
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(40)) goto parse_timeflag;
        break;
      }

      // required int64 timeflag = 5;
      case 5: {
        if (tag == 40) {
         parse_timeflag:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &timeflag_)));
          set_has_timeflag();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:iot_idl.linkage.ActionNodeStatusParameter)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:iot_idl.linkage.ActionNodeStatusParameter)
  return false;
#undef DO_
}

void ActionNodeStatusParameter::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:iot_idl.linkage.ActionNodeStatusParameter)
  // required string action_name = 1;
  if (has_action_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->action_name().data(), this->action_name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "action_name");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      1, this->action_name(), output);
  }

  // required string action_desc = 2;
  if (has_action_desc()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->action_desc().data(), this->action_desc().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "action_desc");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      2, this->action_desc(), output);
  }

  // required .iot_idl.linkage.ENLcsNodeCheckStatus check_state = 3;
  if (has_check_state()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      3, this->check_state(), output);
  }

  // required .iot_idl.linkage.ENLcsStatus node_state = 4;
  if (has_node_state()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      4, this->node_state(), output);
  }

  // required int64 timeflag = 5;
  if (has_timeflag()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(5, this->timeflag(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:iot_idl.linkage.ActionNodeStatusParameter)
}

::google::protobuf::uint8* ActionNodeStatusParameter::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:iot_idl.linkage.ActionNodeStatusParameter)
  // required string action_name = 1;
  if (has_action_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->action_name().data(), this->action_name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "action_name");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        1, this->action_name(), target);
  }

  // required string action_desc = 2;
  if (has_action_desc()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->action_desc().data(), this->action_desc().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "action_desc");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        2, this->action_desc(), target);
  }

  // required .iot_idl.linkage.ENLcsNodeCheckStatus check_state = 3;
  if (has_check_state()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      3, this->check_state(), target);
  }

  // required .iot_idl.linkage.ENLcsStatus node_state = 4;
  if (has_node_state()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      4, this->node_state(), target);
  }

  // required int64 timeflag = 5;
  if (has_timeflag()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(5, this->timeflag(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:iot_idl.linkage.ActionNodeStatusParameter)
  return target;
}

int ActionNodeStatusParameter::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required string action_name = 1;
    if (has_action_name()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->action_name());
    }

    // required string action_desc = 2;
    if (has_action_desc()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->action_desc());
    }

    // required .iot_idl.linkage.ENLcsNodeCheckStatus check_state = 3;
    if (has_check_state()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->check_state());
    }

    // required .iot_idl.linkage.ENLcsStatus node_state = 4;
    if (has_node_state()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->node_state());
    }

    // required int64 timeflag = 5;
    if (has_timeflag()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int64Size(
          this->timeflag());
    }

  }
  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void ActionNodeStatusParameter::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const ActionNodeStatusParameter* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const ActionNodeStatusParameter*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void ActionNodeStatusParameter::MergeFrom(const ActionNodeStatusParameter& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_action_name()) {
      set_action_name(from.action_name());
    }
    if (from.has_action_desc()) {
      set_action_desc(from.action_desc());
    }
    if (from.has_check_state()) {
      set_check_state(from.check_state());
    }
    if (from.has_node_state()) {
      set_node_state(from.node_state());
    }
    if (from.has_timeflag()) {
      set_timeflag(from.timeflag());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void ActionNodeStatusParameter::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void ActionNodeStatusParameter::CopyFrom(const ActionNodeStatusParameter& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ActionNodeStatusParameter::IsInitialized() const {
  if ((_has_bits_[0] & 0x0000001f) != 0x0000001f) return false;

  return true;
}

void ActionNodeStatusParameter::Swap(ActionNodeStatusParameter* other) {
  if (other != this) {
    std::swap(action_name_, other->action_name_);
    std::swap(action_desc_, other->action_desc_);
    std::swap(check_state_, other->check_state_);
    std::swap(node_state_, other->node_state_);
    std::swap(timeflag_, other->timeflag_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata ActionNodeStatusParameter::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = ActionNodeStatusParameter_descriptor_;
  metadata.reflection = ActionNodeStatusParameter_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int FucNodeStatusParameter::kFucNameFieldNumber;
const int FucNodeStatusParameter::kFucDescFieldNumber;
const int FucNodeStatusParameter::kCheckStateFieldNumber;
const int FucNodeStatusParameter::kTimeflagFieldNumber;
const int FucNodeStatusParameter::kNodeStateFieldNumber;
const int FucNodeStatusParameter::kNodelistFieldNumber;
#endif  // !_MSC_VER

FucNodeStatusParameter::FucNodeStatusParameter()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:iot_idl.linkage.FucNodeStatusParameter)
}

void FucNodeStatusParameter::InitAsDefaultInstance() {
}

FucNodeStatusParameter::FucNodeStatusParameter(const FucNodeStatusParameter& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:iot_idl.linkage.FucNodeStatusParameter)
}

void FucNodeStatusParameter::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  fuc_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  fuc_desc_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  check_state_ = 0;
  timeflag_ = GOOGLE_LONGLONG(0);
  node_state_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

FucNodeStatusParameter::~FucNodeStatusParameter() {
  // @@protoc_insertion_point(destructor:iot_idl.linkage.FucNodeStatusParameter)
  SharedDtor();
}

void FucNodeStatusParameter::SharedDtor() {
  if (fuc_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete fuc_name_;
  }
  if (fuc_desc_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete fuc_desc_;
  }
  if (this != default_instance_) {
  }
}

void FucNodeStatusParameter::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* FucNodeStatusParameter::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return FucNodeStatusParameter_descriptor_;
}

const FucNodeStatusParameter& FucNodeStatusParameter::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_LinkageMessage_2eproto();
  return *default_instance_;
}

FucNodeStatusParameter* FucNodeStatusParameter::default_instance_ = NULL;

FucNodeStatusParameter* FucNodeStatusParameter::New() const {
  return new FucNodeStatusParameter;
}

void FucNodeStatusParameter::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<FucNodeStatusParameter*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  if (_has_bits_[0 / 32] & 31) {
    ZR_(timeflag_, node_state_);
    if (has_fuc_name()) {
      if (fuc_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        fuc_name_->clear();
      }
    }
    if (has_fuc_desc()) {
      if (fuc_desc_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        fuc_desc_->clear();
      }
    }
  }

#undef OFFSET_OF_FIELD_
#undef ZR_

  nodelist_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool FucNodeStatusParameter::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:iot_idl.linkage.FucNodeStatusParameter)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required string fuc_name = 1;
      case 1: {
        if (tag == 10) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_fuc_name()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->fuc_name().data(), this->fuc_name().length(),
            ::google::protobuf::internal::WireFormat::PARSE,
            "fuc_name");
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_fuc_desc;
        break;
      }

      // required string fuc_desc = 2;
      case 2: {
        if (tag == 18) {
         parse_fuc_desc:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_fuc_desc()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->fuc_desc().data(), this->fuc_desc().length(),
            ::google::protobuf::internal::WireFormat::PARSE,
            "fuc_desc");
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_check_state;
        break;
      }

      // required .iot_idl.linkage.ENLcsNodeCheckStatus check_state = 3;
      case 3: {
        if (tag == 24) {
         parse_check_state:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::iot_idl::linkage::ENLcsNodeCheckStatus_IsValid(value)) {
            set_check_state(static_cast< ::iot_idl::linkage::ENLcsNodeCheckStatus >(value));
          } else {
            mutable_unknown_fields()->AddVarint(3, value);
          }
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(32)) goto parse_timeflag;
        break;
      }

      // required int64 timeflag = 4;
      case 4: {
        if (tag == 32) {
         parse_timeflag:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &timeflag_)));
          set_has_timeflag();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(40)) goto parse_node_state;
        break;
      }

      // required .iot_idl.linkage.ENLcsStatus node_state = 5;
      case 5: {
        if (tag == 40) {
         parse_node_state:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::iot_idl::linkage::ENLcsStatus_IsValid(value)) {
            set_node_state(static_cast< ::iot_idl::linkage::ENLcsStatus >(value));
          } else {
            mutable_unknown_fields()->AddVarint(5, value);
          }
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(50)) goto parse_nodelist;
        break;
      }

      // repeated .iot_idl.linkage.ActionNodeStatusParameter nodelist = 6;
      case 6: {
        if (tag == 50) {
         parse_nodelist:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_nodelist()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(50)) goto parse_nodelist;
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:iot_idl.linkage.FucNodeStatusParameter)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:iot_idl.linkage.FucNodeStatusParameter)
  return false;
#undef DO_
}

void FucNodeStatusParameter::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:iot_idl.linkage.FucNodeStatusParameter)
  // required string fuc_name = 1;
  if (has_fuc_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->fuc_name().data(), this->fuc_name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "fuc_name");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      1, this->fuc_name(), output);
  }

  // required string fuc_desc = 2;
  if (has_fuc_desc()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->fuc_desc().data(), this->fuc_desc().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "fuc_desc");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      2, this->fuc_desc(), output);
  }

  // required .iot_idl.linkage.ENLcsNodeCheckStatus check_state = 3;
  if (has_check_state()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      3, this->check_state(), output);
  }

  // required int64 timeflag = 4;
  if (has_timeflag()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(4, this->timeflag(), output);
  }

  // required .iot_idl.linkage.ENLcsStatus node_state = 5;
  if (has_node_state()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      5, this->node_state(), output);
  }

  // repeated .iot_idl.linkage.ActionNodeStatusParameter nodelist = 6;
  for (int i = 0; i < this->nodelist_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      6, this->nodelist(i), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:iot_idl.linkage.FucNodeStatusParameter)
}

::google::protobuf::uint8* FucNodeStatusParameter::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:iot_idl.linkage.FucNodeStatusParameter)
  // required string fuc_name = 1;
  if (has_fuc_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->fuc_name().data(), this->fuc_name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "fuc_name");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        1, this->fuc_name(), target);
  }

  // required string fuc_desc = 2;
  if (has_fuc_desc()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->fuc_desc().data(), this->fuc_desc().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "fuc_desc");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        2, this->fuc_desc(), target);
  }

  // required .iot_idl.linkage.ENLcsNodeCheckStatus check_state = 3;
  if (has_check_state()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      3, this->check_state(), target);
  }

  // required int64 timeflag = 4;
  if (has_timeflag()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(4, this->timeflag(), target);
  }

  // required .iot_idl.linkage.ENLcsStatus node_state = 5;
  if (has_node_state()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      5, this->node_state(), target);
  }

  // repeated .iot_idl.linkage.ActionNodeStatusParameter nodelist = 6;
  for (int i = 0; i < this->nodelist_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        6, this->nodelist(i), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:iot_idl.linkage.FucNodeStatusParameter)
  return target;
}

int FucNodeStatusParameter::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required string fuc_name = 1;
    if (has_fuc_name()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->fuc_name());
    }

    // required string fuc_desc = 2;
    if (has_fuc_desc()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->fuc_desc());
    }

    // required .iot_idl.linkage.ENLcsNodeCheckStatus check_state = 3;
    if (has_check_state()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->check_state());
    }

    // required int64 timeflag = 4;
    if (has_timeflag()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int64Size(
          this->timeflag());
    }

    // required .iot_idl.linkage.ENLcsStatus node_state = 5;
    if (has_node_state()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->node_state());
    }

  }
  // repeated .iot_idl.linkage.ActionNodeStatusParameter nodelist = 6;
  total_size += 1 * this->nodelist_size();
  for (int i = 0; i < this->nodelist_size(); i++) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        this->nodelist(i));
  }

  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void FucNodeStatusParameter::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const FucNodeStatusParameter* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const FucNodeStatusParameter*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void FucNodeStatusParameter::MergeFrom(const FucNodeStatusParameter& from) {
  GOOGLE_CHECK_NE(&from, this);
  nodelist_.MergeFrom(from.nodelist_);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_fuc_name()) {
      set_fuc_name(from.fuc_name());
    }
    if (from.has_fuc_desc()) {
      set_fuc_desc(from.fuc_desc());
    }
    if (from.has_check_state()) {
      set_check_state(from.check_state());
    }
    if (from.has_timeflag()) {
      set_timeflag(from.timeflag());
    }
    if (from.has_node_state()) {
      set_node_state(from.node_state());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void FucNodeStatusParameter::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void FucNodeStatusParameter::CopyFrom(const FucNodeStatusParameter& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool FucNodeStatusParameter::IsInitialized() const {
  if ((_has_bits_[0] & 0x0000001f) != 0x0000001f) return false;

  if (!::google::protobuf::internal::AllAreInitialized(this->nodelist())) return false;
  return true;
}

void FucNodeStatusParameter::Swap(FucNodeStatusParameter* other) {
  if (other != this) {
    std::swap(fuc_name_, other->fuc_name_);
    std::swap(fuc_desc_, other->fuc_desc_);
    std::swap(check_state_, other->check_state_);
    std::swap(timeflag_, other->timeflag_);
    std::swap(node_state_, other->node_state_);
    nodelist_.Swap(&other->nodelist_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata FucNodeStatusParameter::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = FucNodeStatusParameter_descriptor_;
  metadata.reflection = FucNodeStatusParameter_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int LinkNodeStatusParameter::kLinkNameFieldNumber;
const int LinkNodeStatusParameter::kLinkDescFieldNumber;
const int LinkNodeStatusParameter::kCheckStateFieldNumber;
const int LinkNodeStatusParameter::kTimeflagFieldNumber;
const int LinkNodeStatusParameter::kNodeStateFieldNumber;
const int LinkNodeStatusParameter::kNodelistFieldNumber;
#endif  // !_MSC_VER

LinkNodeStatusParameter::LinkNodeStatusParameter()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:iot_idl.linkage.LinkNodeStatusParameter)
}

void LinkNodeStatusParameter::InitAsDefaultInstance() {
}

LinkNodeStatusParameter::LinkNodeStatusParameter(const LinkNodeStatusParameter& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:iot_idl.linkage.LinkNodeStatusParameter)
}

void LinkNodeStatusParameter::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  link_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  link_desc_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  check_state_ = 0;
  timeflag_ = GOOGLE_LONGLONG(0);
  node_state_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

LinkNodeStatusParameter::~LinkNodeStatusParameter() {
  // @@protoc_insertion_point(destructor:iot_idl.linkage.LinkNodeStatusParameter)
  SharedDtor();
}

void LinkNodeStatusParameter::SharedDtor() {
  if (link_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete link_name_;
  }
  if (link_desc_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete link_desc_;
  }
  if (this != default_instance_) {
  }
}

void LinkNodeStatusParameter::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* LinkNodeStatusParameter::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return LinkNodeStatusParameter_descriptor_;
}

const LinkNodeStatusParameter& LinkNodeStatusParameter::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_LinkageMessage_2eproto();
  return *default_instance_;
}

LinkNodeStatusParameter* LinkNodeStatusParameter::default_instance_ = NULL;

LinkNodeStatusParameter* LinkNodeStatusParameter::New() const {
  return new LinkNodeStatusParameter;
}

void LinkNodeStatusParameter::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<LinkNodeStatusParameter*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  if (_has_bits_[0 / 32] & 31) {
    ZR_(timeflag_, node_state_);
    if (has_link_name()) {
      if (link_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        link_name_->clear();
      }
    }
    if (has_link_desc()) {
      if (link_desc_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        link_desc_->clear();
      }
    }
  }

#undef OFFSET_OF_FIELD_
#undef ZR_

  nodelist_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool LinkNodeStatusParameter::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:iot_idl.linkage.LinkNodeStatusParameter)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required string link_name = 1;
      case 1: {
        if (tag == 10) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_link_name()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->link_name().data(), this->link_name().length(),
            ::google::protobuf::internal::WireFormat::PARSE,
            "link_name");
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_link_desc;
        break;
      }

      // required string link_desc = 2;
      case 2: {
        if (tag == 18) {
         parse_link_desc:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_link_desc()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->link_desc().data(), this->link_desc().length(),
            ::google::protobuf::internal::WireFormat::PARSE,
            "link_desc");
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_check_state;
        break;
      }

      // required .iot_idl.linkage.ENLcsNodeCheckStatus check_state = 3;
      case 3: {
        if (tag == 24) {
         parse_check_state:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::iot_idl::linkage::ENLcsNodeCheckStatus_IsValid(value)) {
            set_check_state(static_cast< ::iot_idl::linkage::ENLcsNodeCheckStatus >(value));
          } else {
            mutable_unknown_fields()->AddVarint(3, value);
          }
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(32)) goto parse_timeflag;
        break;
      }

      // required int64 timeflag = 4;
      case 4: {
        if (tag == 32) {
         parse_timeflag:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &timeflag_)));
          set_has_timeflag();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(40)) goto parse_node_state;
        break;
      }

      // required .iot_idl.linkage.ENLcsStatus node_state = 5;
      case 5: {
        if (tag == 40) {
         parse_node_state:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::iot_idl::linkage::ENLcsStatus_IsValid(value)) {
            set_node_state(static_cast< ::iot_idl::linkage::ENLcsStatus >(value));
          } else {
            mutable_unknown_fields()->AddVarint(5, value);
          }
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(50)) goto parse_nodelist;
        break;
      }

      // repeated .iot_idl.linkage.FucNodeStatusParameter nodelist = 6;
      case 6: {
        if (tag == 50) {
         parse_nodelist:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_nodelist()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(50)) goto parse_nodelist;
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:iot_idl.linkage.LinkNodeStatusParameter)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:iot_idl.linkage.LinkNodeStatusParameter)
  return false;
#undef DO_
}

void LinkNodeStatusParameter::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:iot_idl.linkage.LinkNodeStatusParameter)
  // required string link_name = 1;
  if (has_link_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->link_name().data(), this->link_name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "link_name");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      1, this->link_name(), output);
  }

  // required string link_desc = 2;
  if (has_link_desc()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->link_desc().data(), this->link_desc().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "link_desc");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      2, this->link_desc(), output);
  }

  // required .iot_idl.linkage.ENLcsNodeCheckStatus check_state = 3;
  if (has_check_state()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      3, this->check_state(), output);
  }

  // required int64 timeflag = 4;
  if (has_timeflag()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(4, this->timeflag(), output);
  }

  // required .iot_idl.linkage.ENLcsStatus node_state = 5;
  if (has_node_state()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      5, this->node_state(), output);
  }

  // repeated .iot_idl.linkage.FucNodeStatusParameter nodelist = 6;
  for (int i = 0; i < this->nodelist_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      6, this->nodelist(i), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:iot_idl.linkage.LinkNodeStatusParameter)
}

::google::protobuf::uint8* LinkNodeStatusParameter::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:iot_idl.linkage.LinkNodeStatusParameter)
  // required string link_name = 1;
  if (has_link_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->link_name().data(), this->link_name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "link_name");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        1, this->link_name(), target);
  }

  // required string link_desc = 2;
  if (has_link_desc()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->link_desc().data(), this->link_desc().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "link_desc");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        2, this->link_desc(), target);
  }

  // required .iot_idl.linkage.ENLcsNodeCheckStatus check_state = 3;
  if (has_check_state()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      3, this->check_state(), target);
  }

  // required int64 timeflag = 4;
  if (has_timeflag()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(4, this->timeflag(), target);
  }

  // required .iot_idl.linkage.ENLcsStatus node_state = 5;
  if (has_node_state()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      5, this->node_state(), target);
  }

  // repeated .iot_idl.linkage.FucNodeStatusParameter nodelist = 6;
  for (int i = 0; i < this->nodelist_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        6, this->nodelist(i), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:iot_idl.linkage.LinkNodeStatusParameter)
  return target;
}

int LinkNodeStatusParameter::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required string link_name = 1;
    if (has_link_name()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->link_name());
    }

    // required string link_desc = 2;
    if (has_link_desc()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->link_desc());
    }

    // required .iot_idl.linkage.ENLcsNodeCheckStatus check_state = 3;
    if (has_check_state()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->check_state());
    }

    // required int64 timeflag = 4;
    if (has_timeflag()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int64Size(
          this->timeflag());
    }

    // required .iot_idl.linkage.ENLcsStatus node_state = 5;
    if (has_node_state()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->node_state());
    }

  }
  // repeated .iot_idl.linkage.FucNodeStatusParameter nodelist = 6;
  total_size += 1 * this->nodelist_size();
  for (int i = 0; i < this->nodelist_size(); i++) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        this->nodelist(i));
  }

  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void LinkNodeStatusParameter::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const LinkNodeStatusParameter* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const LinkNodeStatusParameter*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void LinkNodeStatusParameter::MergeFrom(const LinkNodeStatusParameter& from) {
  GOOGLE_CHECK_NE(&from, this);
  nodelist_.MergeFrom(from.nodelist_);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_link_name()) {
      set_link_name(from.link_name());
    }
    if (from.has_link_desc()) {
      set_link_desc(from.link_desc());
    }
    if (from.has_check_state()) {
      set_check_state(from.check_state());
    }
    if (from.has_timeflag()) {
      set_timeflag(from.timeflag());
    }
    if (from.has_node_state()) {
      set_node_state(from.node_state());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void LinkNodeStatusParameter::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void LinkNodeStatusParameter::CopyFrom(const LinkNodeStatusParameter& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool LinkNodeStatusParameter::IsInitialized() const {
  if ((_has_bits_[0] & 0x0000001f) != 0x0000001f) return false;

  if (!::google::protobuf::internal::AllAreInitialized(this->nodelist())) return false;
  return true;
}

void LinkNodeStatusParameter::Swap(LinkNodeStatusParameter* other) {
  if (other != this) {
    std::swap(link_name_, other->link_name_);
    std::swap(link_desc_, other->link_desc_);
    std::swap(check_state_, other->check_state_);
    std::swap(timeflag_, other->timeflag_);
    std::swap(node_state_, other->node_state_);
    nodelist_.Swap(&other->nodelist_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata LinkNodeStatusParameter::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = LinkNodeStatusParameter_descriptor_;
  metadata.reflection = LinkNodeStatusParameter_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int ActorParameter::kUserIdFieldNumber;
const int ActorParameter::kUserGroupIdFieldNumber;
const int ActorParameter::kHostNameFieldNumber;
const int ActorParameter::kUserNameFieldNumber;
#endif  // !_MSC_VER

ActorParameter::ActorParameter()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:iot_idl.linkage.ActorParameter)
}

void ActorParameter::InitAsDefaultInstance() {
}

ActorParameter::ActorParameter(const ActorParameter& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:iot_idl.linkage.ActorParameter)
}

void ActorParameter::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  user_id_ = 0;
  user_groupid_ = 0;
  host_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  user_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

ActorParameter::~ActorParameter() {
  // @@protoc_insertion_point(destructor:iot_idl.linkage.ActorParameter)
  SharedDtor();
}

void ActorParameter::SharedDtor() {
  if (host_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete host_name_;
  }
  if (user_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete user_name_;
  }
  if (this != default_instance_) {
  }
}

void ActorParameter::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* ActorParameter::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return ActorParameter_descriptor_;
}

const ActorParameter& ActorParameter::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_LinkageMessage_2eproto();
  return *default_instance_;
}

ActorParameter* ActorParameter::default_instance_ = NULL;

ActorParameter* ActorParameter::New() const {
  return new ActorParameter;
}

void ActorParameter::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<ActorParameter*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  if (_has_bits_[0 / 32] & 15) {
    ZR_(user_id_, user_groupid_);
    if (has_host_name()) {
      if (host_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        host_name_->clear();
      }
    }
    if (has_user_name()) {
      if (user_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        user_name_->clear();
      }
    }
  }

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool ActorParameter::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:iot_idl.linkage.ActorParameter)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required int32 user_id = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &user_id_)));
          set_has_user_id();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_user_groupId;
        break;
      }

      // required int32 user_groupId = 2;
      case 2: {
        if (tag == 16) {
         parse_user_groupId:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &user_groupid_)));
          set_has_user_groupid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(26)) goto parse_host_name;
        break;
      }

      // required string host_name = 3;
      case 3: {
        if (tag == 26) {
         parse_host_name:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_host_name()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->host_name().data(), this->host_name().length(),
            ::google::protobuf::internal::WireFormat::PARSE,
            "host_name");
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(34)) goto parse_user_name;
        break;
      }

      // required string user_name = 4;
      case 4: {
        if (tag == 34) {
         parse_user_name:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_user_name()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->user_name().data(), this->user_name().length(),
            ::google::protobuf::internal::WireFormat::PARSE,
            "user_name");
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:iot_idl.linkage.ActorParameter)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:iot_idl.linkage.ActorParameter)
  return false;
#undef DO_
}

void ActorParameter::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:iot_idl.linkage.ActorParameter)
  // required int32 user_id = 1;
  if (has_user_id()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->user_id(), output);
  }

  // required int32 user_groupId = 2;
  if (has_user_groupid()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->user_groupid(), output);
  }

  // required string host_name = 3;
  if (has_host_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->host_name().data(), this->host_name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "host_name");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      3, this->host_name(), output);
  }

  // required string user_name = 4;
  if (has_user_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->user_name().data(), this->user_name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "user_name");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      4, this->user_name(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:iot_idl.linkage.ActorParameter)
}

::google::protobuf::uint8* ActorParameter::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:iot_idl.linkage.ActorParameter)
  // required int32 user_id = 1;
  if (has_user_id()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->user_id(), target);
  }

  // required int32 user_groupId = 2;
  if (has_user_groupid()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->user_groupid(), target);
  }

  // required string host_name = 3;
  if (has_host_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->host_name().data(), this->host_name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "host_name");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        3, this->host_name(), target);
  }

  // required string user_name = 4;
  if (has_user_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->user_name().data(), this->user_name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "user_name");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        4, this->user_name(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:iot_idl.linkage.ActorParameter)
  return target;
}

int ActorParameter::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required int32 user_id = 1;
    if (has_user_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->user_id());
    }

    // required int32 user_groupId = 2;
    if (has_user_groupid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->user_groupid());
    }

    // required string host_name = 3;
    if (has_host_name()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->host_name());
    }

    // required string user_name = 4;
    if (has_user_name()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->user_name());
    }

  }
  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void ActorParameter::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const ActorParameter* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const ActorParameter*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void ActorParameter::MergeFrom(const ActorParameter& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_user_id()) {
      set_user_id(from.user_id());
    }
    if (from.has_user_groupid()) {
      set_user_groupid(from.user_groupid());
    }
    if (from.has_host_name()) {
      set_host_name(from.host_name());
    }
    if (from.has_user_name()) {
      set_user_name(from.user_name());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void ActorParameter::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void ActorParameter::CopyFrom(const ActorParameter& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ActorParameter::IsInitialized() const {
  if ((_has_bits_[0] & 0x0000000f) != 0x0000000f) return false;

  return true;
}

void ActorParameter::Swap(ActorParameter* other) {
  if (other != this) {
    std::swap(user_id_, other->user_id_);
    std::swap(user_groupid_, other->user_groupid_);
    std::swap(host_name_, other->host_name_);
    std::swap(user_name_, other->user_name_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata ActorParameter::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = ActorParameter_descriptor_;
  metadata.reflection = ActorParameter_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int StatusChangeMessage::kPkgHeadFieldNumber;
const int StatusChangeMessage::kNodelistFieldNumber;
const int StatusChangeMessage::kExecuteStatusFieldNumber;
#endif  // !_MSC_VER

StatusChangeMessage::StatusChangeMessage()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:iot_idl.linkage.StatusChangeMessage)
}

void StatusChangeMessage::InitAsDefaultInstance() {
  pkg_head_ = const_cast< ::iot_idl::linkage::LcsPkgHead*>(&::iot_idl::linkage::LcsPkgHead::default_instance());
  nodelist_ = const_cast< ::iot_idl::linkage::LinkNodeStatusParameter*>(&::iot_idl::linkage::LinkNodeStatusParameter::default_instance());
}

StatusChangeMessage::StatusChangeMessage(const StatusChangeMessage& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:iot_idl.linkage.StatusChangeMessage)
}

void StatusChangeMessage::SharedCtor() {
  _cached_size_ = 0;
  pkg_head_ = NULL;
  nodelist_ = NULL;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

StatusChangeMessage::~StatusChangeMessage() {
  // @@protoc_insertion_point(destructor:iot_idl.linkage.StatusChangeMessage)
  SharedDtor();
}

void StatusChangeMessage::SharedDtor() {
  if (this != default_instance_) {
    delete pkg_head_;
    delete nodelist_;
  }
}

void StatusChangeMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* StatusChangeMessage::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return StatusChangeMessage_descriptor_;
}

const StatusChangeMessage& StatusChangeMessage::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_LinkageMessage_2eproto();
  return *default_instance_;
}

StatusChangeMessage* StatusChangeMessage::default_instance_ = NULL;

StatusChangeMessage* StatusChangeMessage::New() const {
  return new StatusChangeMessage;
}

void StatusChangeMessage::Clear() {
  if (_has_bits_[0 / 32] & 3) {
    if (has_pkg_head()) {
      if (pkg_head_ != NULL) pkg_head_->::iot_idl::linkage::LcsPkgHead::Clear();
    }
    if (has_nodelist()) {
      if (nodelist_ != NULL) nodelist_->::iot_idl::linkage::LinkNodeStatusParameter::Clear();
    }
  }
  execute_status_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool StatusChangeMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:iot_idl.linkage.StatusChangeMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required .iot_idl.linkage.LcsPkgHead pkg_head = 1;
      case 1: {
        if (tag == 10) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_pkg_head()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_nodelist;
        break;
      }

      // required .iot_idl.linkage.LinkNodeStatusParameter nodelist = 2;
      case 2: {
        if (tag == 18) {
         parse_nodelist:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_nodelist()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(26)) goto parse_execute_status;
        break;
      }

      // repeated .iot_idl.linkage.ExecuteStatusParameter execute_status = 3;
      case 3: {
        if (tag == 26) {
         parse_execute_status:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_execute_status()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(26)) goto parse_execute_status;
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:iot_idl.linkage.StatusChangeMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:iot_idl.linkage.StatusChangeMessage)
  return false;
#undef DO_
}

void StatusChangeMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:iot_idl.linkage.StatusChangeMessage)
  // required .iot_idl.linkage.LcsPkgHead pkg_head = 1;
  if (has_pkg_head()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, this->pkg_head(), output);
  }

  // required .iot_idl.linkage.LinkNodeStatusParameter nodelist = 2;
  if (has_nodelist()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      2, this->nodelist(), output);
  }

  // repeated .iot_idl.linkage.ExecuteStatusParameter execute_status = 3;
  for (int i = 0; i < this->execute_status_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      3, this->execute_status(i), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:iot_idl.linkage.StatusChangeMessage)
}

::google::protobuf::uint8* StatusChangeMessage::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:iot_idl.linkage.StatusChangeMessage)
  // required .iot_idl.linkage.LcsPkgHead pkg_head = 1;
  if (has_pkg_head()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        1, this->pkg_head(), target);
  }

  // required .iot_idl.linkage.LinkNodeStatusParameter nodelist = 2;
  if (has_nodelist()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        2, this->nodelist(), target);
  }

  // repeated .iot_idl.linkage.ExecuteStatusParameter execute_status = 3;
  for (int i = 0; i < this->execute_status_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        3, this->execute_status(i), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:iot_idl.linkage.StatusChangeMessage)
  return target;
}

int StatusChangeMessage::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required .iot_idl.linkage.LcsPkgHead pkg_head = 1;
    if (has_pkg_head()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->pkg_head());
    }

    // required .iot_idl.linkage.LinkNodeStatusParameter nodelist = 2;
    if (has_nodelist()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->nodelist());
    }

  }
  // repeated .iot_idl.linkage.ExecuteStatusParameter execute_status = 3;
  total_size += 1 * this->execute_status_size();
  for (int i = 0; i < this->execute_status_size(); i++) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        this->execute_status(i));
  }

  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void StatusChangeMessage::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const StatusChangeMessage* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const StatusChangeMessage*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void StatusChangeMessage::MergeFrom(const StatusChangeMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  execute_status_.MergeFrom(from.execute_status_);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_pkg_head()) {
      mutable_pkg_head()->::iot_idl::linkage::LcsPkgHead::MergeFrom(from.pkg_head());
    }
    if (from.has_nodelist()) {
      mutable_nodelist()->::iot_idl::linkage::LinkNodeStatusParameter::MergeFrom(from.nodelist());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void StatusChangeMessage::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void StatusChangeMessage::CopyFrom(const StatusChangeMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool StatusChangeMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;

  if (has_pkg_head()) {
    if (!this->pkg_head().IsInitialized()) return false;
  }
  if (has_nodelist()) {
    if (!this->nodelist().IsInitialized()) return false;
  }
  if (!::google::protobuf::internal::AllAreInitialized(this->execute_status())) return false;
  return true;
}

void StatusChangeMessage::Swap(StatusChangeMessage* other) {
  if (other != this) {
    std::swap(pkg_head_, other->pkg_head_);
    std::swap(nodelist_, other->nodelist_);
    execute_status_.Swap(&other->execute_status_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata StatusChangeMessage::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = StatusChangeMessage_descriptor_;
  metadata.reflection = StatusChangeMessage_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int LinkStartRequestMessage::kPkgHeadFieldNumber;
const int LinkStartRequestMessage::kNodelistFieldNumber;
const int LinkStartRequestMessage::kTriggerTimeFieldNumber;
#endif  // !_MSC_VER

LinkStartRequestMessage::LinkStartRequestMessage()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:iot_idl.linkage.LinkStartRequestMessage)
}

void LinkStartRequestMessage::InitAsDefaultInstance() {
  pkg_head_ = const_cast< ::iot_idl::linkage::LcsPkgHead*>(&::iot_idl::linkage::LcsPkgHead::default_instance());
  nodelist_ = const_cast< ::iot_idl::linkage::LinkNodeStatusParameter*>(&::iot_idl::linkage::LinkNodeStatusParameter::default_instance());
}

LinkStartRequestMessage::LinkStartRequestMessage(const LinkStartRequestMessage& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:iot_idl.linkage.LinkStartRequestMessage)
}

void LinkStartRequestMessage::SharedCtor() {
  _cached_size_ = 0;
  pkg_head_ = NULL;
  nodelist_ = NULL;
  trigger_time_ = GOOGLE_LONGLONG(0);
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

LinkStartRequestMessage::~LinkStartRequestMessage() {
  // @@protoc_insertion_point(destructor:iot_idl.linkage.LinkStartRequestMessage)
  SharedDtor();
}

void LinkStartRequestMessage::SharedDtor() {
  if (this != default_instance_) {
    delete pkg_head_;
    delete nodelist_;
  }
}

void LinkStartRequestMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* LinkStartRequestMessage::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return LinkStartRequestMessage_descriptor_;
}

const LinkStartRequestMessage& LinkStartRequestMessage::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_LinkageMessage_2eproto();
  return *default_instance_;
}

LinkStartRequestMessage* LinkStartRequestMessage::default_instance_ = NULL;

LinkStartRequestMessage* LinkStartRequestMessage::New() const {
  return new LinkStartRequestMessage;
}

void LinkStartRequestMessage::Clear() {
  if (_has_bits_[0 / 32] & 7) {
    if (has_pkg_head()) {
      if (pkg_head_ != NULL) pkg_head_->::iot_idl::linkage::LcsPkgHead::Clear();
    }
    if (has_nodelist()) {
      if (nodelist_ != NULL) nodelist_->::iot_idl::linkage::LinkNodeStatusParameter::Clear();
    }
    trigger_time_ = GOOGLE_LONGLONG(0);
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool LinkStartRequestMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:iot_idl.linkage.LinkStartRequestMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required .iot_idl.linkage.LcsPkgHead pkg_head = 1;
      case 1: {
        if (tag == 10) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_pkg_head()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_nodelist;
        break;
      }

      // required .iot_idl.linkage.LinkNodeStatusParameter nodelist = 2;
      case 2: {
        if (tag == 18) {
         parse_nodelist:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_nodelist()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_trigger_time;
        break;
      }

      // required int64 trigger_time = 3;
      case 3: {
        if (tag == 24) {
         parse_trigger_time:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &trigger_time_)));
          set_has_trigger_time();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:iot_idl.linkage.LinkStartRequestMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:iot_idl.linkage.LinkStartRequestMessage)
  return false;
#undef DO_
}

void LinkStartRequestMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:iot_idl.linkage.LinkStartRequestMessage)
  // required .iot_idl.linkage.LcsPkgHead pkg_head = 1;
  if (has_pkg_head()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, this->pkg_head(), output);
  }

  // required .iot_idl.linkage.LinkNodeStatusParameter nodelist = 2;
  if (has_nodelist()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      2, this->nodelist(), output);
  }

  // required int64 trigger_time = 3;
  if (has_trigger_time()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(3, this->trigger_time(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:iot_idl.linkage.LinkStartRequestMessage)
}

::google::protobuf::uint8* LinkStartRequestMessage::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:iot_idl.linkage.LinkStartRequestMessage)
  // required .iot_idl.linkage.LcsPkgHead pkg_head = 1;
  if (has_pkg_head()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        1, this->pkg_head(), target);
  }

  // required .iot_idl.linkage.LinkNodeStatusParameter nodelist = 2;
  if (has_nodelist()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        2, this->nodelist(), target);
  }

  // required int64 trigger_time = 3;
  if (has_trigger_time()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(3, this->trigger_time(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:iot_idl.linkage.LinkStartRequestMessage)
  return target;
}

int LinkStartRequestMessage::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required .iot_idl.linkage.LcsPkgHead pkg_head = 1;
    if (has_pkg_head()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->pkg_head());
    }

    // required .iot_idl.linkage.LinkNodeStatusParameter nodelist = 2;
    if (has_nodelist()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->nodelist());
    }

    // required int64 trigger_time = 3;
    if (has_trigger_time()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int64Size(
          this->trigger_time());
    }

  }
  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void LinkStartRequestMessage::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const LinkStartRequestMessage* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const LinkStartRequestMessage*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void LinkStartRequestMessage::MergeFrom(const LinkStartRequestMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_pkg_head()) {
      mutable_pkg_head()->::iot_idl::linkage::LcsPkgHead::MergeFrom(from.pkg_head());
    }
    if (from.has_nodelist()) {
      mutable_nodelist()->::iot_idl::linkage::LinkNodeStatusParameter::MergeFrom(from.nodelist());
    }
    if (from.has_trigger_time()) {
      set_trigger_time(from.trigger_time());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void LinkStartRequestMessage::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void LinkStartRequestMessage::CopyFrom(const LinkStartRequestMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool LinkStartRequestMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000007) != 0x00000007) return false;

  if (has_pkg_head()) {
    if (!this->pkg_head().IsInitialized()) return false;
  }
  if (has_nodelist()) {
    if (!this->nodelist().IsInitialized()) return false;
  }
  return true;
}

void LinkStartRequestMessage::Swap(LinkStartRequestMessage* other) {
  if (other != this) {
    std::swap(pkg_head_, other->pkg_head_);
    std::swap(nodelist_, other->nodelist_);
    std::swap(trigger_time_, other->trigger_time_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata LinkStartRequestMessage::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = LinkStartRequestMessage_descriptor_;
  metadata.reflection = LinkStartRequestMessage_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int UiRequestMessage::kPkgHeadFieldNumber;
const int UiRequestMessage::kActorFieldNumber;
const int UiRequestMessage::kNodelistFieldNumber;
const int UiRequestMessage::kExecuteStatusFieldNumber;
#endif  // !_MSC_VER

UiRequestMessage::UiRequestMessage()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:iot_idl.linkage.UiRequestMessage)
}

void UiRequestMessage::InitAsDefaultInstance() {
  pkg_head_ = const_cast< ::iot_idl::linkage::LcsPkgHead*>(&::iot_idl::linkage::LcsPkgHead::default_instance());
  actor_ = const_cast< ::iot_idl::linkage::ActorParameter*>(&::iot_idl::linkage::ActorParameter::default_instance());
  nodelist_ = const_cast< ::iot_idl::linkage::LinkNodeStatusParameter*>(&::iot_idl::linkage::LinkNodeStatusParameter::default_instance());
  execute_status_ = const_cast< ::iot_idl::linkage::ExecuteStatusParameter*>(&::iot_idl::linkage::ExecuteStatusParameter::default_instance());
}

UiRequestMessage::UiRequestMessage(const UiRequestMessage& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:iot_idl.linkage.UiRequestMessage)
}

void UiRequestMessage::SharedCtor() {
  _cached_size_ = 0;
  pkg_head_ = NULL;
  actor_ = NULL;
  nodelist_ = NULL;
  execute_status_ = NULL;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

UiRequestMessage::~UiRequestMessage() {
  // @@protoc_insertion_point(destructor:iot_idl.linkage.UiRequestMessage)
  SharedDtor();
}

void UiRequestMessage::SharedDtor() {
  if (this != default_instance_) {
    delete pkg_head_;
    delete actor_;
    delete nodelist_;
    delete execute_status_;
  }
}

void UiRequestMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* UiRequestMessage::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return UiRequestMessage_descriptor_;
}

const UiRequestMessage& UiRequestMessage::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_LinkageMessage_2eproto();
  return *default_instance_;
}

UiRequestMessage* UiRequestMessage::default_instance_ = NULL;

UiRequestMessage* UiRequestMessage::New() const {
  return new UiRequestMessage;
}

void UiRequestMessage::Clear() {
  if (_has_bits_[0 / 32] & 15) {
    if (has_pkg_head()) {
      if (pkg_head_ != NULL) pkg_head_->::iot_idl::linkage::LcsPkgHead::Clear();
    }
    if (has_actor()) {
      if (actor_ != NULL) actor_->::iot_idl::linkage::ActorParameter::Clear();
    }
    if (has_nodelist()) {
      if (nodelist_ != NULL) nodelist_->::iot_idl::linkage::LinkNodeStatusParameter::Clear();
    }
    if (has_execute_status()) {
      if (execute_status_ != NULL) execute_status_->::iot_idl::linkage::ExecuteStatusParameter::Clear();
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool UiRequestMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:iot_idl.linkage.UiRequestMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required .iot_idl.linkage.LcsPkgHead pkg_head = 1;
      case 1: {
        if (tag == 10) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_pkg_head()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_actor;
        break;
      }

      // required .iot_idl.linkage.ActorParameter actor = 2;
      case 2: {
        if (tag == 18) {
         parse_actor:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_actor()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(26)) goto parse_nodelist;
        break;
      }

      // required .iot_idl.linkage.LinkNodeStatusParameter nodelist = 3;
      case 3: {
        if (tag == 26) {
         parse_nodelist:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_nodelist()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(34)) goto parse_execute_status;
        break;
      }

      // required .iot_idl.linkage.ExecuteStatusParameter execute_status = 4;
      case 4: {
        if (tag == 34) {
         parse_execute_status:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_execute_status()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:iot_idl.linkage.UiRequestMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:iot_idl.linkage.UiRequestMessage)
  return false;
#undef DO_
}

void UiRequestMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:iot_idl.linkage.UiRequestMessage)
  // required .iot_idl.linkage.LcsPkgHead pkg_head = 1;
  if (has_pkg_head()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, this->pkg_head(), output);
  }

  // required .iot_idl.linkage.ActorParameter actor = 2;
  if (has_actor()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      2, this->actor(), output);
  }

  // required .iot_idl.linkage.LinkNodeStatusParameter nodelist = 3;
  if (has_nodelist()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      3, this->nodelist(), output);
  }

  // required .iot_idl.linkage.ExecuteStatusParameter execute_status = 4;
  if (has_execute_status()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      4, this->execute_status(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:iot_idl.linkage.UiRequestMessage)
}

::google::protobuf::uint8* UiRequestMessage::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:iot_idl.linkage.UiRequestMessage)
  // required .iot_idl.linkage.LcsPkgHead pkg_head = 1;
  if (has_pkg_head()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        1, this->pkg_head(), target);
  }

  // required .iot_idl.linkage.ActorParameter actor = 2;
  if (has_actor()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        2, this->actor(), target);
  }

  // required .iot_idl.linkage.LinkNodeStatusParameter nodelist = 3;
  if (has_nodelist()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        3, this->nodelist(), target);
  }

  // required .iot_idl.linkage.ExecuteStatusParameter execute_status = 4;
  if (has_execute_status()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        4, this->execute_status(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:iot_idl.linkage.UiRequestMessage)
  return target;
}

int UiRequestMessage::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required .iot_idl.linkage.LcsPkgHead pkg_head = 1;
    if (has_pkg_head()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->pkg_head());
    }

    // required .iot_idl.linkage.ActorParameter actor = 2;
    if (has_actor()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->actor());
    }

    // required .iot_idl.linkage.LinkNodeStatusParameter nodelist = 3;
    if (has_nodelist()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->nodelist());
    }

    // required .iot_idl.linkage.ExecuteStatusParameter execute_status = 4;
    if (has_execute_status()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->execute_status());
    }

  }
  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void UiRequestMessage::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const UiRequestMessage* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const UiRequestMessage*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void UiRequestMessage::MergeFrom(const UiRequestMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_pkg_head()) {
      mutable_pkg_head()->::iot_idl::linkage::LcsPkgHead::MergeFrom(from.pkg_head());
    }
    if (from.has_actor()) {
      mutable_actor()->::iot_idl::linkage::ActorParameter::MergeFrom(from.actor());
    }
    if (from.has_nodelist()) {
      mutable_nodelist()->::iot_idl::linkage::LinkNodeStatusParameter::MergeFrom(from.nodelist());
    }
    if (from.has_execute_status()) {
      mutable_execute_status()->::iot_idl::linkage::ExecuteStatusParameter::MergeFrom(from.execute_status());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void UiRequestMessage::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void UiRequestMessage::CopyFrom(const UiRequestMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool UiRequestMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x0000000f) != 0x0000000f) return false;

  if (has_pkg_head()) {
    if (!this->pkg_head().IsInitialized()) return false;
  }
  if (has_actor()) {
    if (!this->actor().IsInitialized()) return false;
  }
  if (has_nodelist()) {
    if (!this->nodelist().IsInitialized()) return false;
  }
  if (has_execute_status()) {
    if (!this->execute_status().IsInitialized()) return false;
  }
  return true;
}

void UiRequestMessage::Swap(UiRequestMessage* other) {
  if (other != this) {
    std::swap(pkg_head_, other->pkg_head_);
    std::swap(actor_, other->actor_);
    std::swap(nodelist_, other->nodelist_);
    std::swap(execute_status_, other->execute_status_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata UiRequestMessage::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = UiRequestMessage_descriptor_;
  metadata.reflection = UiRequestMessage_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int UiRequestMessageAck::kPkgHeadFieldNumber;
const int UiRequestMessageAck::kActorFieldNumber;
const int UiRequestMessageAck::kNodelistFieldNumber;
const int UiRequestMessageAck::kOptypeFieldNumber;
#endif  // !_MSC_VER

UiRequestMessageAck::UiRequestMessageAck()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:iot_idl.linkage.UiRequestMessageAck)
}

void UiRequestMessageAck::InitAsDefaultInstance() {
  pkg_head_ = const_cast< ::iot_idl::linkage::LcsPkgHead*>(&::iot_idl::linkage::LcsPkgHead::default_instance());
  actor_ = const_cast< ::iot_idl::linkage::ActorParameter*>(&::iot_idl::linkage::ActorParameter::default_instance());
  nodelist_ = const_cast< ::iot_idl::linkage::LinkNodeStatusParameter*>(&::iot_idl::linkage::LinkNodeStatusParameter::default_instance());
}

UiRequestMessageAck::UiRequestMessageAck(const UiRequestMessageAck& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:iot_idl.linkage.UiRequestMessageAck)
}

void UiRequestMessageAck::SharedCtor() {
  _cached_size_ = 0;
  pkg_head_ = NULL;
  actor_ = NULL;
  nodelist_ = NULL;
  optype_ = 1;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

UiRequestMessageAck::~UiRequestMessageAck() {
  // @@protoc_insertion_point(destructor:iot_idl.linkage.UiRequestMessageAck)
  SharedDtor();
}

void UiRequestMessageAck::SharedDtor() {
  if (this != default_instance_) {
    delete pkg_head_;
    delete actor_;
    delete nodelist_;
  }
}

void UiRequestMessageAck::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* UiRequestMessageAck::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return UiRequestMessageAck_descriptor_;
}

const UiRequestMessageAck& UiRequestMessageAck::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_LinkageMessage_2eproto();
  return *default_instance_;
}

UiRequestMessageAck* UiRequestMessageAck::default_instance_ = NULL;

UiRequestMessageAck* UiRequestMessageAck::New() const {
  return new UiRequestMessageAck;
}

void UiRequestMessageAck::Clear() {
  if (_has_bits_[0 / 32] & 15) {
    if (has_pkg_head()) {
      if (pkg_head_ != NULL) pkg_head_->::iot_idl::linkage::LcsPkgHead::Clear();
    }
    if (has_actor()) {
      if (actor_ != NULL) actor_->::iot_idl::linkage::ActorParameter::Clear();
    }
    if (has_nodelist()) {
      if (nodelist_ != NULL) nodelist_->::iot_idl::linkage::LinkNodeStatusParameter::Clear();
    }
    optype_ = 1;
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool UiRequestMessageAck::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:iot_idl.linkage.UiRequestMessageAck)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required .iot_idl.linkage.LcsPkgHead pkg_head = 1;
      case 1: {
        if (tag == 10) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_pkg_head()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_actor;
        break;
      }

      // required .iot_idl.linkage.ActorParameter actor = 2;
      case 2: {
        if (tag == 18) {
         parse_actor:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_actor()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(26)) goto parse_nodelist;
        break;
      }

      // required .iot_idl.linkage.LinkNodeStatusParameter nodelist = 3;
      case 3: {
        if (tag == 26) {
         parse_nodelist:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_nodelist()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(32)) goto parse_optype;
        break;
      }

      // required .iot_idl.linkage.ENUiOperateType optype = 4;
      case 4: {
        if (tag == 32) {
         parse_optype:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::iot_idl::linkage::ENUiOperateType_IsValid(value)) {
            set_optype(static_cast< ::iot_idl::linkage::ENUiOperateType >(value));
          } else {
            mutable_unknown_fields()->AddVarint(4, value);
          }
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:iot_idl.linkage.UiRequestMessageAck)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:iot_idl.linkage.UiRequestMessageAck)
  return false;
#undef DO_
}

void UiRequestMessageAck::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:iot_idl.linkage.UiRequestMessageAck)
  // required .iot_idl.linkage.LcsPkgHead pkg_head = 1;
  if (has_pkg_head()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, this->pkg_head(), output);
  }

  // required .iot_idl.linkage.ActorParameter actor = 2;
  if (has_actor()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      2, this->actor(), output);
  }

  // required .iot_idl.linkage.LinkNodeStatusParameter nodelist = 3;
  if (has_nodelist()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      3, this->nodelist(), output);
  }

  // required .iot_idl.linkage.ENUiOperateType optype = 4;
  if (has_optype()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      4, this->optype(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:iot_idl.linkage.UiRequestMessageAck)
}

::google::protobuf::uint8* UiRequestMessageAck::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:iot_idl.linkage.UiRequestMessageAck)
  // required .iot_idl.linkage.LcsPkgHead pkg_head = 1;
  if (has_pkg_head()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        1, this->pkg_head(), target);
  }

  // required .iot_idl.linkage.ActorParameter actor = 2;
  if (has_actor()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        2, this->actor(), target);
  }

  // required .iot_idl.linkage.LinkNodeStatusParameter nodelist = 3;
  if (has_nodelist()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        3, this->nodelist(), target);
  }

  // required .iot_idl.linkage.ENUiOperateType optype = 4;
  if (has_optype()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      4, this->optype(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:iot_idl.linkage.UiRequestMessageAck)
  return target;
}

int UiRequestMessageAck::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required .iot_idl.linkage.LcsPkgHead pkg_head = 1;
    if (has_pkg_head()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->pkg_head());
    }

    // required .iot_idl.linkage.ActorParameter actor = 2;
    if (has_actor()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->actor());
    }

    // required .iot_idl.linkage.LinkNodeStatusParameter nodelist = 3;
    if (has_nodelist()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->nodelist());
    }

    // required .iot_idl.linkage.ENUiOperateType optype = 4;
    if (has_optype()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->optype());
    }

  }
  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void UiRequestMessageAck::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const UiRequestMessageAck* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const UiRequestMessageAck*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void UiRequestMessageAck::MergeFrom(const UiRequestMessageAck& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_pkg_head()) {
      mutable_pkg_head()->::iot_idl::linkage::LcsPkgHead::MergeFrom(from.pkg_head());
    }
    if (from.has_actor()) {
      mutable_actor()->::iot_idl::linkage::ActorParameter::MergeFrom(from.actor());
    }
    if (from.has_nodelist()) {
      mutable_nodelist()->::iot_idl::linkage::LinkNodeStatusParameter::MergeFrom(from.nodelist());
    }
    if (from.has_optype()) {
      set_optype(from.optype());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void UiRequestMessageAck::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void UiRequestMessageAck::CopyFrom(const UiRequestMessageAck& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool UiRequestMessageAck::IsInitialized() const {
  if ((_has_bits_[0] & 0x0000000f) != 0x0000000f) return false;

  if (has_pkg_head()) {
    if (!this->pkg_head().IsInitialized()) return false;
  }
  if (has_actor()) {
    if (!this->actor().IsInitialized()) return false;
  }
  if (has_nodelist()) {
    if (!this->nodelist().IsInitialized()) return false;
  }
  return true;
}

void UiRequestMessageAck::Swap(UiRequestMessageAck* other) {
  if (other != this) {
    std::swap(pkg_head_, other->pkg_head_);
    std::swap(actor_, other->actor_);
    std::swap(nodelist_, other->nodelist_);
    std::swap(optype_, other->optype_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata UiRequestMessageAck::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = UiRequestMessageAck_descriptor_;
  metadata.reflection = UiRequestMessageAck_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int LinkOperateMessage::kPkgHeadFieldNumber;
const int LinkOperateMessage::kLinkNodeFieldNumber;
const int LinkOperateMessage::kActorFieldNumber;
const int LinkOperateMessage::kOpreateTypeFieldNumber;
#endif  // !_MSC_VER

LinkOperateMessage::LinkOperateMessage()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:iot_idl.linkage.LinkOperateMessage)
}

void LinkOperateMessage::InitAsDefaultInstance() {
  pkg_head_ = const_cast< ::iot_idl::linkage::LcsPkgHead*>(&::iot_idl::linkage::LcsPkgHead::default_instance());
  link_node_ = const_cast< ::iot_idl::linkage::LinkNodeStatusParameter*>(&::iot_idl::linkage::LinkNodeStatusParameter::default_instance());
  actor_ = const_cast< ::iot_idl::linkage::ActorParameter*>(&::iot_idl::linkage::ActorParameter::default_instance());
}

LinkOperateMessage::LinkOperateMessage(const LinkOperateMessage& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:iot_idl.linkage.LinkOperateMessage)
}

void LinkOperateMessage::SharedCtor() {
  _cached_size_ = 0;
  pkg_head_ = NULL;
  link_node_ = NULL;
  actor_ = NULL;
  opreate_type_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

LinkOperateMessage::~LinkOperateMessage() {
  // @@protoc_insertion_point(destructor:iot_idl.linkage.LinkOperateMessage)
  SharedDtor();
}

void LinkOperateMessage::SharedDtor() {
  if (this != default_instance_) {
    delete pkg_head_;
    delete link_node_;
    delete actor_;
  }
}

void LinkOperateMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* LinkOperateMessage::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return LinkOperateMessage_descriptor_;
}

const LinkOperateMessage& LinkOperateMessage::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_LinkageMessage_2eproto();
  return *default_instance_;
}

LinkOperateMessage* LinkOperateMessage::default_instance_ = NULL;

LinkOperateMessage* LinkOperateMessage::New() const {
  return new LinkOperateMessage;
}

void LinkOperateMessage::Clear() {
  if (_has_bits_[0 / 32] & 15) {
    if (has_pkg_head()) {
      if (pkg_head_ != NULL) pkg_head_->::iot_idl::linkage::LcsPkgHead::Clear();
    }
    if (has_link_node()) {
      if (link_node_ != NULL) link_node_->::iot_idl::linkage::LinkNodeStatusParameter::Clear();
    }
    if (has_actor()) {
      if (actor_ != NULL) actor_->::iot_idl::linkage::ActorParameter::Clear();
    }
    opreate_type_ = 0;
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool LinkOperateMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:iot_idl.linkage.LinkOperateMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required .iot_idl.linkage.LcsPkgHead pkg_head = 1;
      case 1: {
        if (tag == 10) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_pkg_head()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_link_node;
        break;
      }

      // required .iot_idl.linkage.LinkNodeStatusParameter link_node = 2;
      case 2: {
        if (tag == 18) {
         parse_link_node:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_link_node()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(26)) goto parse_actor;
        break;
      }

      // required .iot_idl.linkage.ActorParameter actor = 3;
      case 3: {
        if (tag == 26) {
         parse_actor:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_actor()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(32)) goto parse_opreate_type;
        break;
      }

      // required .iot_idl.linkage.ENLinkOperateType opreate_type = 4;
      case 4: {
        if (tag == 32) {
         parse_opreate_type:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::iot_idl::linkage::ENLinkOperateType_IsValid(value)) {
            set_opreate_type(static_cast< ::iot_idl::linkage::ENLinkOperateType >(value));
          } else {
            mutable_unknown_fields()->AddVarint(4, value);
          }
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:iot_idl.linkage.LinkOperateMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:iot_idl.linkage.LinkOperateMessage)
  return false;
#undef DO_
}

void LinkOperateMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:iot_idl.linkage.LinkOperateMessage)
  // required .iot_idl.linkage.LcsPkgHead pkg_head = 1;
  if (has_pkg_head()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, this->pkg_head(), output);
  }

  // required .iot_idl.linkage.LinkNodeStatusParameter link_node = 2;
  if (has_link_node()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      2, this->link_node(), output);
  }

  // required .iot_idl.linkage.ActorParameter actor = 3;
  if (has_actor()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      3, this->actor(), output);
  }

  // required .iot_idl.linkage.ENLinkOperateType opreate_type = 4;
  if (has_opreate_type()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      4, this->opreate_type(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:iot_idl.linkage.LinkOperateMessage)
}

::google::protobuf::uint8* LinkOperateMessage::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:iot_idl.linkage.LinkOperateMessage)
  // required .iot_idl.linkage.LcsPkgHead pkg_head = 1;
  if (has_pkg_head()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        1, this->pkg_head(), target);
  }

  // required .iot_idl.linkage.LinkNodeStatusParameter link_node = 2;
  if (has_link_node()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        2, this->link_node(), target);
  }

  // required .iot_idl.linkage.ActorParameter actor = 3;
  if (has_actor()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        3, this->actor(), target);
  }

  // required .iot_idl.linkage.ENLinkOperateType opreate_type = 4;
  if (has_opreate_type()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      4, this->opreate_type(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:iot_idl.linkage.LinkOperateMessage)
  return target;
}

int LinkOperateMessage::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required .iot_idl.linkage.LcsPkgHead pkg_head = 1;
    if (has_pkg_head()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->pkg_head());
    }

    // required .iot_idl.linkage.LinkNodeStatusParameter link_node = 2;
    if (has_link_node()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->link_node());
    }

    // required .iot_idl.linkage.ActorParameter actor = 3;
    if (has_actor()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->actor());
    }

    // required .iot_idl.linkage.ENLinkOperateType opreate_type = 4;
    if (has_opreate_type()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->opreate_type());
    }

  }
  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void LinkOperateMessage::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const LinkOperateMessage* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const LinkOperateMessage*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void LinkOperateMessage::MergeFrom(const LinkOperateMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_pkg_head()) {
      mutable_pkg_head()->::iot_idl::linkage::LcsPkgHead::MergeFrom(from.pkg_head());
    }
    if (from.has_link_node()) {
      mutable_link_node()->::iot_idl::linkage::LinkNodeStatusParameter::MergeFrom(from.link_node());
    }
    if (from.has_actor()) {
      mutable_actor()->::iot_idl::linkage::ActorParameter::MergeFrom(from.actor());
    }
    if (from.has_opreate_type()) {
      set_opreate_type(from.opreate_type());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void LinkOperateMessage::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void LinkOperateMessage::CopyFrom(const LinkOperateMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool LinkOperateMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x0000000f) != 0x0000000f) return false;

  if (has_pkg_head()) {
    if (!this->pkg_head().IsInitialized()) return false;
  }
  if (has_link_node()) {
    if (!this->link_node().IsInitialized()) return false;
  }
  if (has_actor()) {
    if (!this->actor().IsInitialized()) return false;
  }
  return true;
}

void LinkOperateMessage::Swap(LinkOperateMessage* other) {
  if (other != this) {
    std::swap(pkg_head_, other->pkg_head_);
    std::swap(link_node_, other->link_node_);
    std::swap(actor_, other->actor_);
    std::swap(opreate_type_, other->opreate_type_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata LinkOperateMessage::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = LinkOperateMessage_descriptor_;
  metadata.reflection = LinkOperateMessage_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int LinkOperateMessageAck::kPkgHeadFieldNumber;
const int LinkOperateMessageAck::kLinkNodeFieldNumber;
const int LinkOperateMessageAck::kOpreateTypeFieldNumber;
const int LinkOperateMessageAck::kActorFieldNumber;
const int LinkOperateMessageAck::kExecuteStatusFieldNumber;
#endif  // !_MSC_VER

LinkOperateMessageAck::LinkOperateMessageAck()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:iot_idl.linkage.LinkOperateMessageAck)
}

void LinkOperateMessageAck::InitAsDefaultInstance() {
  pkg_head_ = const_cast< ::iot_idl::linkage::LcsPkgHead*>(&::iot_idl::linkage::LcsPkgHead::default_instance());
  link_node_ = const_cast< ::iot_idl::linkage::LinkNodeStatusParameter*>(&::iot_idl::linkage::LinkNodeStatusParameter::default_instance());
  actor_ = const_cast< ::iot_idl::linkage::ActorParameter*>(&::iot_idl::linkage::ActorParameter::default_instance());
  execute_status_ = const_cast< ::iot_idl::linkage::ExecuteStatusParameter*>(&::iot_idl::linkage::ExecuteStatusParameter::default_instance());
}

LinkOperateMessageAck::LinkOperateMessageAck(const LinkOperateMessageAck& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:iot_idl.linkage.LinkOperateMessageAck)
}

void LinkOperateMessageAck::SharedCtor() {
  _cached_size_ = 0;
  pkg_head_ = NULL;
  link_node_ = NULL;
  opreate_type_ = 0;
  actor_ = NULL;
  execute_status_ = NULL;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

LinkOperateMessageAck::~LinkOperateMessageAck() {
  // @@protoc_insertion_point(destructor:iot_idl.linkage.LinkOperateMessageAck)
  SharedDtor();
}

void LinkOperateMessageAck::SharedDtor() {
  if (this != default_instance_) {
    delete pkg_head_;
    delete link_node_;
    delete actor_;
    delete execute_status_;
  }
}

void LinkOperateMessageAck::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* LinkOperateMessageAck::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return LinkOperateMessageAck_descriptor_;
}

const LinkOperateMessageAck& LinkOperateMessageAck::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_LinkageMessage_2eproto();
  return *default_instance_;
}

LinkOperateMessageAck* LinkOperateMessageAck::default_instance_ = NULL;

LinkOperateMessageAck* LinkOperateMessageAck::New() const {
  return new LinkOperateMessageAck;
}

void LinkOperateMessageAck::Clear() {
  if (_has_bits_[0 / 32] & 31) {
    if (has_pkg_head()) {
      if (pkg_head_ != NULL) pkg_head_->::iot_idl::linkage::LcsPkgHead::Clear();
    }
    if (has_link_node()) {
      if (link_node_ != NULL) link_node_->::iot_idl::linkage::LinkNodeStatusParameter::Clear();
    }
    opreate_type_ = 0;
    if (has_actor()) {
      if (actor_ != NULL) actor_->::iot_idl::linkage::ActorParameter::Clear();
    }
    if (has_execute_status()) {
      if (execute_status_ != NULL) execute_status_->::iot_idl::linkage::ExecuteStatusParameter::Clear();
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool LinkOperateMessageAck::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:iot_idl.linkage.LinkOperateMessageAck)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required .iot_idl.linkage.LcsPkgHead pkg_head = 1;
      case 1: {
        if (tag == 10) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_pkg_head()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_link_node;
        break;
      }

      // required .iot_idl.linkage.LinkNodeStatusParameter link_node = 2;
      case 2: {
        if (tag == 18) {
         parse_link_node:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_link_node()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_opreate_type;
        break;
      }

      // required .iot_idl.linkage.ENLinkOperateType opreate_type = 3;
      case 3: {
        if (tag == 24) {
         parse_opreate_type:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::iot_idl::linkage::ENLinkOperateType_IsValid(value)) {
            set_opreate_type(static_cast< ::iot_idl::linkage::ENLinkOperateType >(value));
          } else {
            mutable_unknown_fields()->AddVarint(3, value);
          }
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(34)) goto parse_actor;
        break;
      }

      // required .iot_idl.linkage.ActorParameter actor = 4;
      case 4: {
        if (tag == 34) {
         parse_actor:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_actor()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(42)) goto parse_execute_status;
        break;
      }

      // required .iot_idl.linkage.ExecuteStatusParameter execute_status = 5;
      case 5: {
        if (tag == 42) {
         parse_execute_status:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_execute_status()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:iot_idl.linkage.LinkOperateMessageAck)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:iot_idl.linkage.LinkOperateMessageAck)
  return false;
#undef DO_
}

void LinkOperateMessageAck::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:iot_idl.linkage.LinkOperateMessageAck)
  // required .iot_idl.linkage.LcsPkgHead pkg_head = 1;
  if (has_pkg_head()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, this->pkg_head(), output);
  }

  // required .iot_idl.linkage.LinkNodeStatusParameter link_node = 2;
  if (has_link_node()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      2, this->link_node(), output);
  }

  // required .iot_idl.linkage.ENLinkOperateType opreate_type = 3;
  if (has_opreate_type()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      3, this->opreate_type(), output);
  }

  // required .iot_idl.linkage.ActorParameter actor = 4;
  if (has_actor()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      4, this->actor(), output);
  }

  // required .iot_idl.linkage.ExecuteStatusParameter execute_status = 5;
  if (has_execute_status()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      5, this->execute_status(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:iot_idl.linkage.LinkOperateMessageAck)
}

::google::protobuf::uint8* LinkOperateMessageAck::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:iot_idl.linkage.LinkOperateMessageAck)
  // required .iot_idl.linkage.LcsPkgHead pkg_head = 1;
  if (has_pkg_head()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        1, this->pkg_head(), target);
  }

  // required .iot_idl.linkage.LinkNodeStatusParameter link_node = 2;
  if (has_link_node()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        2, this->link_node(), target);
  }

  // required .iot_idl.linkage.ENLinkOperateType opreate_type = 3;
  if (has_opreate_type()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      3, this->opreate_type(), target);
  }

  // required .iot_idl.linkage.ActorParameter actor = 4;
  if (has_actor()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        4, this->actor(), target);
  }

  // required .iot_idl.linkage.ExecuteStatusParameter execute_status = 5;
  if (has_execute_status()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        5, this->execute_status(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:iot_idl.linkage.LinkOperateMessageAck)
  return target;
}

int LinkOperateMessageAck::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required .iot_idl.linkage.LcsPkgHead pkg_head = 1;
    if (has_pkg_head()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->pkg_head());
    }

    // required .iot_idl.linkage.LinkNodeStatusParameter link_node = 2;
    if (has_link_node()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->link_node());
    }

    // required .iot_idl.linkage.ENLinkOperateType opreate_type = 3;
    if (has_opreate_type()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->opreate_type());
    }

    // required .iot_idl.linkage.ActorParameter actor = 4;
    if (has_actor()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->actor());
    }

    // required .iot_idl.linkage.ExecuteStatusParameter execute_status = 5;
    if (has_execute_status()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->execute_status());
    }

  }
  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void LinkOperateMessageAck::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const LinkOperateMessageAck* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const LinkOperateMessageAck*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void LinkOperateMessageAck::MergeFrom(const LinkOperateMessageAck& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_pkg_head()) {
      mutable_pkg_head()->::iot_idl::linkage::LcsPkgHead::MergeFrom(from.pkg_head());
    }
    if (from.has_link_node()) {
      mutable_link_node()->::iot_idl::linkage::LinkNodeStatusParameter::MergeFrom(from.link_node());
    }
    if (from.has_opreate_type()) {
      set_opreate_type(from.opreate_type());
    }
    if (from.has_actor()) {
      mutable_actor()->::iot_idl::linkage::ActorParameter::MergeFrom(from.actor());
    }
    if (from.has_execute_status()) {
      mutable_execute_status()->::iot_idl::linkage::ExecuteStatusParameter::MergeFrom(from.execute_status());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void LinkOperateMessageAck::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void LinkOperateMessageAck::CopyFrom(const LinkOperateMessageAck& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool LinkOperateMessageAck::IsInitialized() const {
  if ((_has_bits_[0] & 0x0000001f) != 0x0000001f) return false;

  if (has_pkg_head()) {
    if (!this->pkg_head().IsInitialized()) return false;
  }
  if (has_link_node()) {
    if (!this->link_node().IsInitialized()) return false;
  }
  if (has_actor()) {
    if (!this->actor().IsInitialized()) return false;
  }
  if (has_execute_status()) {
    if (!this->execute_status().IsInitialized()) return false;
  }
  return true;
}

void LinkOperateMessageAck::Swap(LinkOperateMessageAck* other) {
  if (other != this) {
    std::swap(pkg_head_, other->pkg_head_);
    std::swap(link_node_, other->link_node_);
    std::swap(opreate_type_, other->opreate_type_);
    std::swap(actor_, other->actor_);
    std::swap(execute_status_, other->execute_status_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata LinkOperateMessageAck::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = LinkOperateMessageAck_descriptor_;
  metadata.reflection = LinkOperateMessageAck_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int PushParameter::kGraphNameFieldNumber;
#endif  // !_MSC_VER

PushParameter::PushParameter()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:iot_idl.linkage.PushParameter)
}

void PushParameter::InitAsDefaultInstance() {
}

PushParameter::PushParameter(const PushParameter& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:iot_idl.linkage.PushParameter)
}

void PushParameter::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  graph_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

PushParameter::~PushParameter() {
  // @@protoc_insertion_point(destructor:iot_idl.linkage.PushParameter)
  SharedDtor();
}

void PushParameter::SharedDtor() {
  if (graph_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete graph_name_;
  }
  if (this != default_instance_) {
  }
}

void PushParameter::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* PushParameter::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return PushParameter_descriptor_;
}

const PushParameter& PushParameter::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_LinkageMessage_2eproto();
  return *default_instance_;
}

PushParameter* PushParameter::default_instance_ = NULL;

PushParameter* PushParameter::New() const {
  return new PushParameter;
}

void PushParameter::Clear() {
  if (has_graph_name()) {
    if (graph_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
      graph_name_->clear();
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool PushParameter::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:iot_idl.linkage.PushParameter)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required string graph_name = 1;
      case 1: {
        if (tag == 10) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_graph_name()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->graph_name().data(), this->graph_name().length(),
            ::google::protobuf::internal::WireFormat::PARSE,
            "graph_name");
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:iot_idl.linkage.PushParameter)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:iot_idl.linkage.PushParameter)
  return false;
#undef DO_
}

void PushParameter::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:iot_idl.linkage.PushParameter)
  // required string graph_name = 1;
  if (has_graph_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->graph_name().data(), this->graph_name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "graph_name");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      1, this->graph_name(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:iot_idl.linkage.PushParameter)
}

::google::protobuf::uint8* PushParameter::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:iot_idl.linkage.PushParameter)
  // required string graph_name = 1;
  if (has_graph_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->graph_name().data(), this->graph_name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "graph_name");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        1, this->graph_name(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:iot_idl.linkage.PushParameter)
  return target;
}

int PushParameter::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required string graph_name = 1;
    if (has_graph_name()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->graph_name());
    }

  }
  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void PushParameter::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const PushParameter* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const PushParameter*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void PushParameter::MergeFrom(const PushParameter& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_graph_name()) {
      set_graph_name(from.graph_name());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void PushParameter::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void PushParameter::CopyFrom(const PushParameter& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool PushParameter::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;

  return true;
}

void PushParameter::Swap(PushParameter* other) {
  if (other != this) {
    std::swap(graph_name_, other->graph_name_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata PushParameter::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = PushParameter_descriptor_;
  metadata.reflection = PushParameter_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int HintParameter::kHintInfoFieldNumber;
#endif  // !_MSC_VER

HintParameter::HintParameter()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:iot_idl.linkage.HintParameter)
}

void HintParameter::InitAsDefaultInstance() {
}

HintParameter::HintParameter(const HintParameter& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:iot_idl.linkage.HintParameter)
}

void HintParameter::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  hint_info_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

HintParameter::~HintParameter() {
  // @@protoc_insertion_point(destructor:iot_idl.linkage.HintParameter)
  SharedDtor();
}

void HintParameter::SharedDtor() {
  if (hint_info_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete hint_info_;
  }
  if (this != default_instance_) {
  }
}

void HintParameter::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* HintParameter::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return HintParameter_descriptor_;
}

const HintParameter& HintParameter::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_LinkageMessage_2eproto();
  return *default_instance_;
}

HintParameter* HintParameter::default_instance_ = NULL;

HintParameter* HintParameter::New() const {
  return new HintParameter;
}

void HintParameter::Clear() {
  if (has_hint_info()) {
    if (hint_info_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
      hint_info_->clear();
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool HintParameter::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:iot_idl.linkage.HintParameter)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required string hint_info = 1;
      case 1: {
        if (tag == 10) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_hint_info()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->hint_info().data(), this->hint_info().length(),
            ::google::protobuf::internal::WireFormat::PARSE,
            "hint_info");
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:iot_idl.linkage.HintParameter)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:iot_idl.linkage.HintParameter)
  return false;
#undef DO_
}

void HintParameter::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:iot_idl.linkage.HintParameter)
  // required string hint_info = 1;
  if (has_hint_info()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->hint_info().data(), this->hint_info().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "hint_info");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      1, this->hint_info(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:iot_idl.linkage.HintParameter)
}

::google::protobuf::uint8* HintParameter::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:iot_idl.linkage.HintParameter)
  // required string hint_info = 1;
  if (has_hint_info()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->hint_info().data(), this->hint_info().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "hint_info");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        1, this->hint_info(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:iot_idl.linkage.HintParameter)
  return target;
}

int HintParameter::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required string hint_info = 1;
    if (has_hint_info()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->hint_info());
    }

  }
  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void HintParameter::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const HintParameter* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const HintParameter*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void HintParameter::MergeFrom(const HintParameter& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_hint_info()) {
      set_hint_info(from.hint_info());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void HintParameter::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void HintParameter::CopyFrom(const HintParameter& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool HintParameter::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;

  return true;
}

void HintParameter::Swap(HintParameter* other) {
  if (other != this) {
    std::swap(hint_info_, other->hint_info_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata HintParameter::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = HintParameter_descriptor_;
  metadata.reflection = HintParameter_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int ActionToHmiMessage::kPkgHeadFieldNumber;
const int ActionToHmiMessage::kActionTypeFieldNumber;
const int ActionToHmiMessage::kHostNameFieldNumber;
const int ActionToHmiMessage::kPushParamFieldNumber;
const int ActionToHmiMessage::kHintParamFieldNumber;
#endif  // !_MSC_VER

ActionToHmiMessage::ActionToHmiMessage()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:iot_idl.linkage.ActionToHmiMessage)
}

void ActionToHmiMessage::InitAsDefaultInstance() {
  pkg_head_ = const_cast< ::iot_idl::linkage::LcsPkgHead*>(&::iot_idl::linkage::LcsPkgHead::default_instance());
  push_param_ = const_cast< ::iot_idl::linkage::PushParameter*>(&::iot_idl::linkage::PushParameter::default_instance());
  hint_param_ = const_cast< ::iot_idl::linkage::HintParameter*>(&::iot_idl::linkage::HintParameter::default_instance());
}

ActionToHmiMessage::ActionToHmiMessage(const ActionToHmiMessage& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:iot_idl.linkage.ActionToHmiMessage)
}

void ActionToHmiMessage::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  pkg_head_ = NULL;
  action_type_ = 0;
  host_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  push_param_ = NULL;
  hint_param_ = NULL;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

ActionToHmiMessage::~ActionToHmiMessage() {
  // @@protoc_insertion_point(destructor:iot_idl.linkage.ActionToHmiMessage)
  SharedDtor();
}

void ActionToHmiMessage::SharedDtor() {
  if (host_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete host_name_;
  }
  if (this != default_instance_) {
    delete pkg_head_;
    delete push_param_;
    delete hint_param_;
  }
}

void ActionToHmiMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* ActionToHmiMessage::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return ActionToHmiMessage_descriptor_;
}

const ActionToHmiMessage& ActionToHmiMessage::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_LinkageMessage_2eproto();
  return *default_instance_;
}

ActionToHmiMessage* ActionToHmiMessage::default_instance_ = NULL;

ActionToHmiMessage* ActionToHmiMessage::New() const {
  return new ActionToHmiMessage;
}

void ActionToHmiMessage::Clear() {
  if (_has_bits_[0 / 32] & 31) {
    if (has_pkg_head()) {
      if (pkg_head_ != NULL) pkg_head_->::iot_idl::linkage::LcsPkgHead::Clear();
    }
    action_type_ = 0;
    if (has_host_name()) {
      if (host_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        host_name_->clear();
      }
    }
    if (has_push_param()) {
      if (push_param_ != NULL) push_param_->::iot_idl::linkage::PushParameter::Clear();
    }
    if (has_hint_param()) {
      if (hint_param_ != NULL) hint_param_->::iot_idl::linkage::HintParameter::Clear();
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool ActionToHmiMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:iot_idl.linkage.ActionToHmiMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required .iot_idl.linkage.LcsPkgHead pkg_head = 1;
      case 1: {
        if (tag == 10) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_pkg_head()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_action_type;
        break;
      }

      // required .iot_idl.linkage.ENActionOperateType action_type = 2;
      case 2: {
        if (tag == 16) {
         parse_action_type:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::iot_idl::linkage::ENActionOperateType_IsValid(value)) {
            set_action_type(static_cast< ::iot_idl::linkage::ENActionOperateType >(value));
          } else {
            mutable_unknown_fields()->AddVarint(2, value);
          }
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(26)) goto parse_host_name;
        break;
      }

      // required string host_name = 3;
      case 3: {
        if (tag == 26) {
         parse_host_name:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_host_name()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->host_name().data(), this->host_name().length(),
            ::google::protobuf::internal::WireFormat::PARSE,
            "host_name");
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(34)) goto parse_push_param;
        break;
      }

      // optional .iot_idl.linkage.PushParameter push_param = 4;
      case 4: {
        if (tag == 34) {
         parse_push_param:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_push_param()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(42)) goto parse_hint_param;
        break;
      }

      // optional .iot_idl.linkage.HintParameter hint_param = 5;
      case 5: {
        if (tag == 42) {
         parse_hint_param:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_hint_param()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:iot_idl.linkage.ActionToHmiMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:iot_idl.linkage.ActionToHmiMessage)
  return false;
#undef DO_
}

void ActionToHmiMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:iot_idl.linkage.ActionToHmiMessage)
  // required .iot_idl.linkage.LcsPkgHead pkg_head = 1;
  if (has_pkg_head()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, this->pkg_head(), output);
  }

  // required .iot_idl.linkage.ENActionOperateType action_type = 2;
  if (has_action_type()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      2, this->action_type(), output);
  }

  // required string host_name = 3;
  if (has_host_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->host_name().data(), this->host_name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "host_name");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      3, this->host_name(), output);
  }

  // optional .iot_idl.linkage.PushParameter push_param = 4;
  if (has_push_param()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      4, this->push_param(), output);
  }

  // optional .iot_idl.linkage.HintParameter hint_param = 5;
  if (has_hint_param()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      5, this->hint_param(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:iot_idl.linkage.ActionToHmiMessage)
}

::google::protobuf::uint8* ActionToHmiMessage::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:iot_idl.linkage.ActionToHmiMessage)
  // required .iot_idl.linkage.LcsPkgHead pkg_head = 1;
  if (has_pkg_head()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        1, this->pkg_head(), target);
  }

  // required .iot_idl.linkage.ENActionOperateType action_type = 2;
  if (has_action_type()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      2, this->action_type(), target);
  }

  // required string host_name = 3;
  if (has_host_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->host_name().data(), this->host_name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "host_name");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        3, this->host_name(), target);
  }

  // optional .iot_idl.linkage.PushParameter push_param = 4;
  if (has_push_param()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        4, this->push_param(), target);
  }

  // optional .iot_idl.linkage.HintParameter hint_param = 5;
  if (has_hint_param()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        5, this->hint_param(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:iot_idl.linkage.ActionToHmiMessage)
  return target;
}

int ActionToHmiMessage::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required .iot_idl.linkage.LcsPkgHead pkg_head = 1;
    if (has_pkg_head()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->pkg_head());
    }

    // required .iot_idl.linkage.ENActionOperateType action_type = 2;
    if (has_action_type()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->action_type());
    }

    // required string host_name = 3;
    if (has_host_name()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->host_name());
    }

    // optional .iot_idl.linkage.PushParameter push_param = 4;
    if (has_push_param()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->push_param());
    }

    // optional .iot_idl.linkage.HintParameter hint_param = 5;
    if (has_hint_param()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->hint_param());
    }

  }
  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void ActionToHmiMessage::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const ActionToHmiMessage* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const ActionToHmiMessage*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void ActionToHmiMessage::MergeFrom(const ActionToHmiMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_pkg_head()) {
      mutable_pkg_head()->::iot_idl::linkage::LcsPkgHead::MergeFrom(from.pkg_head());
    }
    if (from.has_action_type()) {
      set_action_type(from.action_type());
    }
    if (from.has_host_name()) {
      set_host_name(from.host_name());
    }
    if (from.has_push_param()) {
      mutable_push_param()->::iot_idl::linkage::PushParameter::MergeFrom(from.push_param());
    }
    if (from.has_hint_param()) {
      mutable_hint_param()->::iot_idl::linkage::HintParameter::MergeFrom(from.hint_param());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void ActionToHmiMessage::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void ActionToHmiMessage::CopyFrom(const ActionToHmiMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ActionToHmiMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000007) != 0x00000007) return false;

  if (has_pkg_head()) {
    if (!this->pkg_head().IsInitialized()) return false;
  }
  if (has_push_param()) {
    if (!this->push_param().IsInitialized()) return false;
  }
  if (has_hint_param()) {
    if (!this->hint_param().IsInitialized()) return false;
  }
  return true;
}

void ActionToHmiMessage::Swap(ActionToHmiMessage* other) {
  if (other != this) {
    std::swap(pkg_head_, other->pkg_head_);
    std::swap(action_type_, other->action_type_);
    std::swap(host_name_, other->host_name_);
    std::swap(push_param_, other->push_param_);
    std::swap(hint_param_, other->hint_param_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata ActionToHmiMessage::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = ActionToHmiMessage_descriptor_;
  metadata.reflection = ActionToHmiMessage_reflection_;
  return metadata;
}


// @@protoc_insertion_point(namespace_scope)

}  // namespace linkage
}  // namespace iot_idl

// @@protoc_insertion_point(global_scope)