HM-SPMS/product/src/idl_files/FileSynch.pb.h

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

#ifndef PROTOBUF_FileSynch_2eproto__INCLUDED
#define PROTOBUF_FileSynch_2eproto__INCLUDED

#include <string>

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

#if GOOGLE_PROTOBUF_VERSION < 2006000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers.  Please update
#error your headers.
#endif
#if 2006001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers.  Please
#error regenerate this file with a newer version of protoc.
#endif

#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>
#include <google/protobuf/extension_set.h>
#include <google/protobuf/generated_enum_reflection.h>
#include <google/protobuf/unknown_field_set.h>
// @@protoc_insertion_point(includes)

namespace kbd_idlfile {

// Internal implementation detail -- do not call these.
void IDL_FILES_EXPORT protobuf_AddDesc_FileSynch_2eproto();
void protobuf_AssignDesc_FileSynch_2eproto();
void protobuf_ShutdownFile_FileSynch_2eproto();

class DataBlock;
class DataPack;
class FileNode;
class FileNodeReqMsg;
class FileNodeRespMsg;
class FileChangeReqMsg;
class FileChangeExeMsg;
class BroadcastTaskMsg;
class ExeBroadcastMsg;
class BroadcastResultMsg;

enum enTaskType {
  enTaskType_STOP = 0,
  enTaskType_ONLY_NODE = 1,
  enTaskType_DATA_NODE = 2
};
IDL_FILES_EXPORT bool enTaskType_IsValid(int value);
const enTaskType enTaskType_MIN = enTaskType_STOP;
const enTaskType enTaskType_MAX = enTaskType_DATA_NODE;
const int enTaskType_ARRAYSIZE = enTaskType_MAX + 1;

IDL_FILES_EXPORT const ::google::protobuf::EnumDescriptor* enTaskType_descriptor();
inline const ::std::string& enTaskType_Name(enTaskType value) {
  return ::google::protobuf::internal::NameOfEnum(
    enTaskType_descriptor(), value);
}
inline bool enTaskType_Parse(
    const ::std::string& name, enTaskType* value) {
  return ::google::protobuf::internal::ParseNamedEnum<enTaskType>(
    enTaskType_descriptor(), name, value);
}
enum enTaskStatusType {
  enTask_START = 1,
  enTask_END = 2,
  enTask_EXEING = 3
};
IDL_FILES_EXPORT bool enTaskStatusType_IsValid(int value);
const enTaskStatusType enTaskStatusType_MIN = enTask_START;
const enTaskStatusType enTaskStatusType_MAX = enTask_EXEING;
const int enTaskStatusType_ARRAYSIZE = enTaskStatusType_MAX + 1;

IDL_FILES_EXPORT const ::google::protobuf::EnumDescriptor* enTaskStatusType_descriptor();
inline const ::std::string& enTaskStatusType_Name(enTaskStatusType value) {
  return ::google::protobuf::internal::NameOfEnum(
    enTaskStatusType_descriptor(), value);
}
inline bool enTaskStatusType_Parse(
    const ::std::string& name, enTaskStatusType* value) {
  return ::google::protobuf::internal::ParseNamedEnum<enTaskStatusType>(
    enTaskStatusType_descriptor(), name, value);
}
// ===================================================================

class IDL_FILES_EXPORT DataBlock : public ::google::protobuf::Message {
 public:
  DataBlock();
  virtual ~DataBlock();

  DataBlock(const DataBlock& from);

  inline DataBlock& operator=(const DataBlock& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const DataBlock& default_instance();

  void Swap(DataBlock* other);

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

  DataBlock* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const DataBlock& from);
  void MergeFrom(const DataBlock& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // required uint64 index = 1;
  inline bool has_index() const;
  inline void clear_index();
  static const int kIndexFieldNumber = 1;
  inline ::google::protobuf::uint64 index() const;
  inline void set_index(::google::protobuf::uint64 value);

  // required uint64 offset = 2;
  inline bool has_offset() const;
  inline void clear_offset();
  static const int kOffsetFieldNumber = 2;
  inline ::google::protobuf::uint64 offset() const;
  inline void set_offset(::google::protobuf::uint64 value);

  // required uint64 len = 3;
  inline bool has_len() const;
  inline void clear_len();
  static const int kLenFieldNumber = 3;
  inline ::google::protobuf::uint64 len() const;
  inline void set_len(::google::protobuf::uint64 value);

  // required bytes buff = 4;
  inline bool has_buff() const;
  inline void clear_buff();
  static const int kBuffFieldNumber = 4;
  inline const ::std::string& buff() const;
  inline void set_buff(const ::std::string& value);
  inline void set_buff(const char* value);
  inline void set_buff(const void* value, size_t size);
  inline ::std::string* mutable_buff();
  inline ::std::string* release_buff();
  inline void set_allocated_buff(::std::string* buff);

  // @@protoc_insertion_point(class_scope:kbd_idlfile.DataBlock)
 private:
  inline void set_has_index();
  inline void clear_has_index();
  inline void set_has_offset();
  inline void clear_has_offset();
  inline void set_has_len();
  inline void clear_has_len();
  inline void set_has_buff();
  inline void clear_has_buff();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::google::protobuf::uint64 index_;
  ::google::protobuf::uint64 offset_;
  ::google::protobuf::uint64 len_;
  ::std::string* buff_;
  friend void IDL_FILES_EXPORT protobuf_AddDesc_FileSynch_2eproto();
  friend void protobuf_AssignDesc_FileSynch_2eproto();
  friend void protobuf_ShutdownFile_FileSynch_2eproto();

  void InitAsDefaultInstance();
  static DataBlock* default_instance_;
};
// -------------------------------------------------------------------

class IDL_FILES_EXPORT DataPack : public ::google::protobuf::Message {
 public:
  DataPack();
  virtual ~DataPack();

  DataPack(const DataPack& from);

  inline DataPack& operator=(const DataPack& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const DataPack& default_instance();

  void Swap(DataPack* other);

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

  DataPack* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const DataPack& from);
  void MergeFrom(const DataPack& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // required string pathFile = 1;
  inline bool has_pathfile() const;
  inline void clear_pathfile();
  static const int kPathFileFieldNumber = 1;
  inline const ::std::string& pathfile() const;
  inline void set_pathfile(const ::std::string& value);
  inline void set_pathfile(const char* value);
  inline void set_pathfile(const char* value, size_t size);
  inline ::std::string* mutable_pathfile();
  inline ::std::string* release_pathfile();
  inline void set_allocated_pathfile(::std::string* pathfile);

  // required uint64 blockCount = 2;
  inline bool has_blockcount() const;
  inline void clear_blockcount();
  static const int kBlockCountFieldNumber = 2;
  inline ::google::protobuf::uint64 blockcount() const;
  inline void set_blockcount(::google::protobuf::uint64 value);

  // required int32 isDir = 3;
  inline bool has_isdir() const;
  inline void clear_isdir();
  static const int kIsDirFieldNumber = 3;
  inline ::google::protobuf::int32 isdir() const;
  inline void set_isdir(::google::protobuf::int32 value);

  // required uint64 fileSize = 4;
  inline bool has_filesize() const;
  inline void clear_filesize();
  static const int kFileSizeFieldNumber = 4;
  inline ::google::protobuf::uint64 filesize() const;
  inline void set_filesize(::google::protobuf::uint64 value);

  // required string checkCode = 5;
  inline bool has_checkcode() const;
  inline void clear_checkcode();
  static const int kCheckCodeFieldNumber = 5;
  inline const ::std::string& checkcode() const;
  inline void set_checkcode(const ::std::string& value);
  inline void set_checkcode(const char* value);
  inline void set_checkcode(const char* value, size_t size);
  inline ::std::string* mutable_checkcode();
  inline ::std::string* release_checkcode();
  inline void set_allocated_checkcode(::std::string* checkcode);

  // optional .kbd_idlfile.DataBlock dataBlock = 6;
  inline bool has_datablock() const;
  inline void clear_datablock();
  static const int kDataBlockFieldNumber = 6;
  inline const ::kbd_idlfile::DataBlock& datablock() const;
  inline ::kbd_idlfile::DataBlock* mutable_datablock();
  inline ::kbd_idlfile::DataBlock* release_datablock();
  inline void set_allocated_datablock(::kbd_idlfile::DataBlock* datablock);

  // optional string renamePathFile = 7;
  inline bool has_renamepathfile() const;
  inline void clear_renamepathfile();
  static const int kRenamePathFileFieldNumber = 7;
  inline const ::std::string& renamepathfile() const;
  inline void set_renamepathfile(const ::std::string& value);
  inline void set_renamepathfile(const char* value);
  inline void set_renamepathfile(const char* value, size_t size);
  inline ::std::string* mutable_renamepathfile();
  inline ::std::string* release_renamepathfile();
  inline void set_allocated_renamepathfile(::std::string* renamepathfile);

  // @@protoc_insertion_point(class_scope:kbd_idlfile.DataPack)
 private:
  inline void set_has_pathfile();
  inline void clear_has_pathfile();
  inline void set_has_blockcount();
  inline void clear_has_blockcount();
  inline void set_has_isdir();
  inline void clear_has_isdir();
  inline void set_has_filesize();
  inline void clear_has_filesize();
  inline void set_has_checkcode();
  inline void clear_has_checkcode();
  inline void set_has_datablock();
  inline void clear_has_datablock();
  inline void set_has_renamepathfile();
  inline void clear_has_renamepathfile();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::std::string* pathfile_;
  ::google::protobuf::uint64 blockcount_;
  ::google::protobuf::uint64 filesize_;
  ::std::string* checkcode_;
  ::kbd_idlfile::DataBlock* datablock_;
  ::std::string* renamepathfile_;
  ::google::protobuf::int32 isdir_;
  friend void IDL_FILES_EXPORT protobuf_AddDesc_FileSynch_2eproto();
  friend void protobuf_AssignDesc_FileSynch_2eproto();
  friend void protobuf_ShutdownFile_FileSynch_2eproto();

  void InitAsDefaultInstance();
  static DataPack* default_instance_;
};
// -------------------------------------------------------------------

class IDL_FILES_EXPORT FileNode : public ::google::protobuf::Message {
 public:
  FileNode();
  virtual ~FileNode();

  FileNode(const FileNode& from);

  inline FileNode& operator=(const FileNode& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const FileNode& default_instance();

  void Swap(FileNode* other);

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

  FileNode* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const FileNode& from);
  void MergeFrom(const FileNode& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // required string pathFile = 1;
  inline bool has_pathfile() const;
  inline void clear_pathfile();
  static const int kPathFileFieldNumber = 1;
  inline const ::std::string& pathfile() const;
  inline void set_pathfile(const ::std::string& value);
  inline void set_pathfile(const char* value);
  inline void set_pathfile(const char* value, size_t size);
  inline ::std::string* mutable_pathfile();
  inline ::std::string* release_pathfile();
  inline void set_allocated_pathfile(::std::string* pathfile);

  // required int32 isDir = 2;
  inline bool has_isdir() const;
  inline void clear_isdir();
  static const int kIsDirFieldNumber = 2;
  inline ::google::protobuf::int32 isdir() const;
  inline void set_isdir(::google::protobuf::int32 value);

  // required int32 isConfigPath = 3;
  inline bool has_isconfigpath() const;
  inline void clear_isconfigpath();
  static const int kIsConfigPathFieldNumber = 3;
  inline ::google::protobuf::int32 isconfigpath() const;
  inline void set_isconfigpath(::google::protobuf::int32 value);

  // optional uint64 fileSize = 4;
  inline bool has_filesize() const;
  inline void clear_filesize();
  static const int kFileSizeFieldNumber = 4;
  inline ::google::protobuf::uint64 filesize() const;
  inline void set_filesize(::google::protobuf::uint64 value);

  // optional uint64 modifyTime = 5;
  inline bool has_modifytime() const;
  inline void clear_modifytime();
  static const int kModifyTimeFieldNumber = 5;
  inline ::google::protobuf::uint64 modifytime() const;
  inline void set_modifytime(::google::protobuf::uint64 value);

  // repeated .kbd_idlfile.FileNode childNode = 6;
  inline int childnode_size() const;
  inline void clear_childnode();
  static const int kChildNodeFieldNumber = 6;
  inline const ::kbd_idlfile::FileNode& childnode(int index) const;
  inline ::kbd_idlfile::FileNode* mutable_childnode(int index);
  inline ::kbd_idlfile::FileNode* add_childnode();
  inline const ::google::protobuf::RepeatedPtrField< ::kbd_idlfile::FileNode >&
      childnode() const;
  inline ::google::protobuf::RepeatedPtrField< ::kbd_idlfile::FileNode >*
      mutable_childnode();

  // @@protoc_insertion_point(class_scope:kbd_idlfile.FileNode)
 private:
  inline void set_has_pathfile();
  inline void clear_has_pathfile();
  inline void set_has_isdir();
  inline void clear_has_isdir();
  inline void set_has_isconfigpath();
  inline void clear_has_isconfigpath();
  inline void set_has_filesize();
  inline void clear_has_filesize();
  inline void set_has_modifytime();
  inline void clear_has_modifytime();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::std::string* pathfile_;
  ::google::protobuf::int32 isdir_;
  ::google::protobuf::int32 isconfigpath_;
  ::google::protobuf::uint64 filesize_;
  ::google::protobuf::uint64 modifytime_;
  ::google::protobuf::RepeatedPtrField< ::kbd_idlfile::FileNode > childnode_;
  friend void IDL_FILES_EXPORT protobuf_AddDesc_FileSynch_2eproto();
  friend void protobuf_AssignDesc_FileSynch_2eproto();
  friend void protobuf_ShutdownFile_FileSynch_2eproto();

  void InitAsDefaultInstance();
  static FileNode* default_instance_;
};
// -------------------------------------------------------------------

class IDL_FILES_EXPORT FileNodeReqMsg : public ::google::protobuf::Message {
 public:
  FileNodeReqMsg();
  virtual ~FileNodeReqMsg();

  FileNodeReqMsg(const FileNodeReqMsg& from);

  inline FileNodeReqMsg& operator=(const FileNodeReqMsg& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const FileNodeReqMsg& default_instance();

  void Swap(FileNodeReqMsg* other);

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

  FileNodeReqMsg* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const FileNodeReqMsg& from);
  void MergeFrom(const FileNodeReqMsg& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // required string hostName = 1;
  inline bool has_hostname() const;
  inline void clear_hostname();
  static const int kHostNameFieldNumber = 1;
  inline const ::std::string& hostname() const;
  inline void set_hostname(const ::std::string& value);
  inline void set_hostname(const char* value);
  inline void set_hostname(const char* value, size_t size);
  inline ::std::string* mutable_hostname();
  inline ::std::string* release_hostname();
  inline void set_allocated_hostname(::std::string* hostname);

  // repeated string pathFile = 2;
  inline int pathfile_size() const;
  inline void clear_pathfile();
  static const int kPathFileFieldNumber = 2;
  inline const ::std::string& pathfile(int index) const;
  inline ::std::string* mutable_pathfile(int index);
  inline void set_pathfile(int index, const ::std::string& value);
  inline void set_pathfile(int index, const char* value);
  inline void set_pathfile(int index, const char* value, size_t size);
  inline ::std::string* add_pathfile();
  inline void add_pathfile(const ::std::string& value);
  inline void add_pathfile(const char* value);
  inline void add_pathfile(const char* value, size_t size);
  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& pathfile() const;
  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_pathfile();

  // @@protoc_insertion_point(class_scope:kbd_idlfile.FileNodeReqMsg)
 private:
  inline void set_has_hostname();
  inline void clear_has_hostname();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::std::string* hostname_;
  ::google::protobuf::RepeatedPtrField< ::std::string> pathfile_;
  friend void IDL_FILES_EXPORT protobuf_AddDesc_FileSynch_2eproto();
  friend void protobuf_AssignDesc_FileSynch_2eproto();
  friend void protobuf_ShutdownFile_FileSynch_2eproto();

  void InitAsDefaultInstance();
  static FileNodeReqMsg* default_instance_;
};
// -------------------------------------------------------------------

class IDL_FILES_EXPORT FileNodeRespMsg : public ::google::protobuf::Message {
 public:
  FileNodeRespMsg();
  virtual ~FileNodeRespMsg();

  FileNodeRespMsg(const FileNodeRespMsg& from);

  inline FileNodeRespMsg& operator=(const FileNodeRespMsg& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const FileNodeRespMsg& default_instance();

  void Swap(FileNodeRespMsg* other);

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

  FileNodeRespMsg* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const FileNodeRespMsg& from);
  void MergeFrom(const FileNodeRespMsg& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // required string hostName = 1;
  inline bool has_hostname() const;
  inline void clear_hostname();
  static const int kHostNameFieldNumber = 1;
  inline const ::std::string& hostname() const;
  inline void set_hostname(const ::std::string& value);
  inline void set_hostname(const char* value);
  inline void set_hostname(const char* value, size_t size);
  inline ::std::string* mutable_hostname();
  inline ::std::string* release_hostname();
  inline void set_allocated_hostname(::std::string* hostname);

  // required int32 isRoot = 2;
  inline bool has_isroot() const;
  inline void clear_isroot();
  static const int kIsRootFieldNumber = 2;
  inline ::google::protobuf::int32 isroot() const;
  inline void set_isroot(::google::protobuf::int32 value);

  // repeated .kbd_idlfile.FileNode node = 3;
  inline int node_size() const;
  inline void clear_node();
  static const int kNodeFieldNumber = 3;
  inline const ::kbd_idlfile::FileNode& node(int index) const;
  inline ::kbd_idlfile::FileNode* mutable_node(int index);
  inline ::kbd_idlfile::FileNode* add_node();
  inline const ::google::protobuf::RepeatedPtrField< ::kbd_idlfile::FileNode >&
      node() const;
  inline ::google::protobuf::RepeatedPtrField< ::kbd_idlfile::FileNode >*
      mutable_node();

  // @@protoc_insertion_point(class_scope:kbd_idlfile.FileNodeRespMsg)
 private:
  inline void set_has_hostname();
  inline void clear_has_hostname();
  inline void set_has_isroot();
  inline void clear_has_isroot();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::std::string* hostname_;
  ::google::protobuf::RepeatedPtrField< ::kbd_idlfile::FileNode > node_;
  ::google::protobuf::int32 isroot_;
  friend void IDL_FILES_EXPORT protobuf_AddDesc_FileSynch_2eproto();
  friend void protobuf_AssignDesc_FileSynch_2eproto();
  friend void protobuf_ShutdownFile_FileSynch_2eproto();

  void InitAsDefaultInstance();
  static FileNodeRespMsg* default_instance_;
};
// -------------------------------------------------------------------

class IDL_FILES_EXPORT FileChangeReqMsg : public ::google::protobuf::Message {
 public:
  FileChangeReqMsg();
  virtual ~FileChangeReqMsg();

  FileChangeReqMsg(const FileChangeReqMsg& from);

  inline FileChangeReqMsg& operator=(const FileChangeReqMsg& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const FileChangeReqMsg& default_instance();

  void Swap(FileChangeReqMsg* other);

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

  FileChangeReqMsg* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const FileChangeReqMsg& from);
  void MergeFrom(const FileChangeReqMsg& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // required string hostName = 1;
  inline bool has_hostname() const;
  inline void clear_hostname();
  static const int kHostNameFieldNumber = 1;
  inline const ::std::string& hostname() const;
  inline void set_hostname(const ::std::string& value);
  inline void set_hostname(const char* value);
  inline void set_hostname(const char* value, size_t size);
  inline ::std::string* mutable_hostname();
  inline ::std::string* release_hostname();
  inline void set_allocated_hostname(::std::string* hostname);

  // required int32 optType = 2;
  inline bool has_opttype() const;
  inline void clear_opttype();
  static const int kOptTypeFieldNumber = 2;
  inline ::google::protobuf::int32 opttype() const;
  inline void set_opttype(::google::protobuf::int32 value);

  // required string pathFile = 3;
  inline bool has_pathfile() const;
  inline void clear_pathfile();
  static const int kPathFileFieldNumber = 3;
  inline const ::std::string& pathfile() const;
  inline void set_pathfile(const ::std::string& value);
  inline void set_pathfile(const char* value);
  inline void set_pathfile(const char* value, size_t size);
  inline ::std::string* mutable_pathfile();
  inline ::std::string* release_pathfile();
  inline void set_allocated_pathfile(::std::string* pathfile);

  // @@protoc_insertion_point(class_scope:kbd_idlfile.FileChangeReqMsg)
 private:
  inline void set_has_hostname();
  inline void clear_has_hostname();
  inline void set_has_opttype();
  inline void clear_has_opttype();
  inline void set_has_pathfile();
  inline void clear_has_pathfile();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::std::string* hostname_;
  ::std::string* pathfile_;
  ::google::protobuf::int32 opttype_;
  friend void IDL_FILES_EXPORT protobuf_AddDesc_FileSynch_2eproto();
  friend void protobuf_AssignDesc_FileSynch_2eproto();
  friend void protobuf_ShutdownFile_FileSynch_2eproto();

  void InitAsDefaultInstance();
  static FileChangeReqMsg* default_instance_;
};
// -------------------------------------------------------------------

class IDL_FILES_EXPORT FileChangeExeMsg : public ::google::protobuf::Message {
 public:
  FileChangeExeMsg();
  virtual ~FileChangeExeMsg();

  FileChangeExeMsg(const FileChangeExeMsg& from);

  inline FileChangeExeMsg& operator=(const FileChangeExeMsg& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const FileChangeExeMsg& default_instance();

  void Swap(FileChangeExeMsg* other);

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

  FileChangeExeMsg* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const FileChangeExeMsg& from);
  void MergeFrom(const FileChangeExeMsg& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // required string hostName = 1;
  inline bool has_hostname() const;
  inline void clear_hostname();
  static const int kHostNameFieldNumber = 1;
  inline const ::std::string& hostname() const;
  inline void set_hostname(const ::std::string& value);
  inline void set_hostname(const char* value);
  inline void set_hostname(const char* value, size_t size);
  inline ::std::string* mutable_hostname();
  inline ::std::string* release_hostname();
  inline void set_allocated_hostname(::std::string* hostname);

  // required int32 optType = 2;
  inline bool has_opttype() const;
  inline void clear_opttype();
  static const int kOptTypeFieldNumber = 2;
  inline ::google::protobuf::int32 opttype() const;
  inline void set_opttype(::google::protobuf::int32 value);

  // required string pathFile = 3;
  inline bool has_pathfile() const;
  inline void clear_pathfile();
  static const int kPathFileFieldNumber = 3;
  inline const ::std::string& pathfile() const;
  inline void set_pathfile(const ::std::string& value);
  inline void set_pathfile(const char* value);
  inline void set_pathfile(const char* value, size_t size);
  inline ::std::string* mutable_pathfile();
  inline ::std::string* release_pathfile();
  inline void set_allocated_pathfile(::std::string* pathfile);

  // required .kbd_idlfile.DataPack dataPack = 4;
  inline bool has_datapack() const;
  inline void clear_datapack();
  static const int kDataPackFieldNumber = 4;
  inline const ::kbd_idlfile::DataPack& datapack() const;
  inline ::kbd_idlfile::DataPack* mutable_datapack();
  inline ::kbd_idlfile::DataPack* release_datapack();
  inline void set_allocated_datapack(::kbd_idlfile::DataPack* datapack);

  // @@protoc_insertion_point(class_scope:kbd_idlfile.FileChangeExeMsg)
 private:
  inline void set_has_hostname();
  inline void clear_has_hostname();
  inline void set_has_opttype();
  inline void clear_has_opttype();
  inline void set_has_pathfile();
  inline void clear_has_pathfile();
  inline void set_has_datapack();
  inline void clear_has_datapack();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::std::string* hostname_;
  ::std::string* pathfile_;
  ::kbd_idlfile::DataPack* datapack_;
  ::google::protobuf::int32 opttype_;
  friend void IDL_FILES_EXPORT protobuf_AddDesc_FileSynch_2eproto();
  friend void protobuf_AssignDesc_FileSynch_2eproto();
  friend void protobuf_ShutdownFile_FileSynch_2eproto();

  void InitAsDefaultInstance();
  static FileChangeExeMsg* default_instance_;
};
// -------------------------------------------------------------------

class IDL_FILES_EXPORT BroadcastTaskMsg : public ::google::protobuf::Message {
 public:
  BroadcastTaskMsg();
  virtual ~BroadcastTaskMsg();

  BroadcastTaskMsg(const BroadcastTaskMsg& from);

  inline BroadcastTaskMsg& operator=(const BroadcastTaskMsg& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const BroadcastTaskMsg& default_instance();

  void Swap(BroadcastTaskMsg* other);

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

  BroadcastTaskMsg* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const BroadcastTaskMsg& from);
  void MergeFrom(const BroadcastTaskMsg& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // required string hostName = 1;
  inline bool has_hostname() const;
  inline void clear_hostname();
  static const int kHostNameFieldNumber = 1;
  inline const ::std::string& hostname() const;
  inline void set_hostname(const ::std::string& value);
  inline void set_hostname(const char* value);
  inline void set_hostname(const char* value, size_t size);
  inline ::std::string* mutable_hostname();
  inline ::std::string* release_hostname();
  inline void set_allocated_hostname(::std::string* hostname);

  // required string recvHostName = 2;
  inline bool has_recvhostname() const;
  inline void clear_recvhostname();
  static const int kRecvHostNameFieldNumber = 2;
  inline const ::std::string& recvhostname() const;
  inline void set_recvhostname(const ::std::string& value);
  inline void set_recvhostname(const char* value);
  inline void set_recvhostname(const char* value, size_t size);
  inline ::std::string* mutable_recvhostname();
  inline ::std::string* release_recvhostname();
  inline void set_allocated_recvhostname(::std::string* recvhostname);

  // required uint64 taskTime = 3;
  inline bool has_tasktime() const;
  inline void clear_tasktime();
  static const int kTaskTimeFieldNumber = 3;
  inline ::google::protobuf::uint64 tasktime() const;
  inline void set_tasktime(::google::protobuf::uint64 value);

  // repeated string pathFile = 4;
  inline int pathfile_size() const;
  inline void clear_pathfile();
  static const int kPathFileFieldNumber = 4;
  inline const ::std::string& pathfile(int index) const;
  inline ::std::string* mutable_pathfile(int index);
  inline void set_pathfile(int index, const ::std::string& value);
  inline void set_pathfile(int index, const char* value);
  inline void set_pathfile(int index, const char* value, size_t size);
  inline ::std::string* add_pathfile();
  inline void add_pathfile(const ::std::string& value);
  inline void add_pathfile(const char* value);
  inline void add_pathfile(const char* value, size_t size);
  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& pathfile() const;
  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_pathfile();

  // required .kbd_idlfile.enTaskType operate = 5;
  inline bool has_operate() const;
  inline void clear_operate();
  static const int kOperateFieldNumber = 5;
  inline ::kbd_idlfile::enTaskType operate() const;
  inline void set_operate(::kbd_idlfile::enTaskType value);

  // @@protoc_insertion_point(class_scope:kbd_idlfile.BroadcastTaskMsg)
 private:
  inline void set_has_hostname();
  inline void clear_has_hostname();
  inline void set_has_recvhostname();
  inline void clear_has_recvhostname();
  inline void set_has_tasktime();
  inline void clear_has_tasktime();
  inline void set_has_operate();
  inline void clear_has_operate();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::std::string* hostname_;
  ::std::string* recvhostname_;
  ::google::protobuf::uint64 tasktime_;
  ::google::protobuf::RepeatedPtrField< ::std::string> pathfile_;
  int operate_;
  friend void IDL_FILES_EXPORT protobuf_AddDesc_FileSynch_2eproto();
  friend void protobuf_AssignDesc_FileSynch_2eproto();
  friend void protobuf_ShutdownFile_FileSynch_2eproto();

  void InitAsDefaultInstance();
  static BroadcastTaskMsg* default_instance_;
};
// -------------------------------------------------------------------

class IDL_FILES_EXPORT ExeBroadcastMsg : public ::google::protobuf::Message {
 public:
  ExeBroadcastMsg();
  virtual ~ExeBroadcastMsg();

  ExeBroadcastMsg(const ExeBroadcastMsg& from);

  inline ExeBroadcastMsg& operator=(const ExeBroadcastMsg& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const ExeBroadcastMsg& default_instance();

  void Swap(ExeBroadcastMsg* other);

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

  ExeBroadcastMsg* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const ExeBroadcastMsg& from);
  void MergeFrom(const ExeBroadcastMsg& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // required string hostName = 1;
  inline bool has_hostname() const;
  inline void clear_hostname();
  static const int kHostNameFieldNumber = 1;
  inline const ::std::string& hostname() const;
  inline void set_hostname(const ::std::string& value);
  inline void set_hostname(const char* value);
  inline void set_hostname(const char* value, size_t size);
  inline ::std::string* mutable_hostname();
  inline ::std::string* release_hostname();
  inline void set_allocated_hostname(::std::string* hostname);

  // required .kbd_idlfile.BroadcastTaskMsg task = 2;
  inline bool has_task() const;
  inline void clear_task();
  static const int kTaskFieldNumber = 2;
  inline const ::kbd_idlfile::BroadcastTaskMsg& task() const;
  inline ::kbd_idlfile::BroadcastTaskMsg* mutable_task();
  inline ::kbd_idlfile::BroadcastTaskMsg* release_task();
  inline void set_allocated_task(::kbd_idlfile::BroadcastTaskMsg* task);

  // required uint64 taskTime = 3;
  inline bool has_tasktime() const;
  inline void clear_tasktime();
  static const int kTaskTimeFieldNumber = 3;
  inline ::google::protobuf::uint64 tasktime() const;
  inline void set_tasktime(::google::protobuf::uint64 value);

  // required int32 count = 4;
  inline bool has_count() const;
  inline void clear_count();
  static const int kCountFieldNumber = 4;
  inline ::google::protobuf::int32 count() const;
  inline void set_count(::google::protobuf::int32 value);

  // required int32 sendCount = 5;
  inline bool has_sendcount() const;
  inline void clear_sendcount();
  static const int kSendCountFieldNumber = 5;
  inline ::google::protobuf::int32 sendcount() const;
  inline void set_sendcount(::google::protobuf::int32 value);

  // optional .kbd_idlfile.FileNode node = 6;
  inline bool has_node() const;
  inline void clear_node();
  static const int kNodeFieldNumber = 6;
  inline const ::kbd_idlfile::FileNode& node() const;
  inline ::kbd_idlfile::FileNode* mutable_node();
  inline ::kbd_idlfile::FileNode* release_node();
  inline void set_allocated_node(::kbd_idlfile::FileNode* node);

  // optional .kbd_idlfile.DataPack dataPack = 7;
  inline bool has_datapack() const;
  inline void clear_datapack();
  static const int kDataPackFieldNumber = 7;
  inline const ::kbd_idlfile::DataPack& datapack() const;
  inline ::kbd_idlfile::DataPack* mutable_datapack();
  inline ::kbd_idlfile::DataPack* release_datapack();
  inline void set_allocated_datapack(::kbd_idlfile::DataPack* datapack);

  // @@protoc_insertion_point(class_scope:kbd_idlfile.ExeBroadcastMsg)
 private:
  inline void set_has_hostname();
  inline void clear_has_hostname();
  inline void set_has_task();
  inline void clear_has_task();
  inline void set_has_tasktime();
  inline void clear_has_tasktime();
  inline void set_has_count();
  inline void clear_has_count();
  inline void set_has_sendcount();
  inline void clear_has_sendcount();
  inline void set_has_node();
  inline void clear_has_node();
  inline void set_has_datapack();
  inline void clear_has_datapack();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::std::string* hostname_;
  ::kbd_idlfile::BroadcastTaskMsg* task_;
  ::google::protobuf::uint64 tasktime_;
  ::google::protobuf::int32 count_;
  ::google::protobuf::int32 sendcount_;
  ::kbd_idlfile::FileNode* node_;
  ::kbd_idlfile::DataPack* datapack_;
  friend void IDL_FILES_EXPORT protobuf_AddDesc_FileSynch_2eproto();
  friend void protobuf_AssignDesc_FileSynch_2eproto();
  friend void protobuf_ShutdownFile_FileSynch_2eproto();

  void InitAsDefaultInstance();
  static ExeBroadcastMsg* default_instance_;
};
// -------------------------------------------------------------------

class IDL_FILES_EXPORT BroadcastResultMsg : public ::google::protobuf::Message {
 public:
  BroadcastResultMsg();
  virtual ~BroadcastResultMsg();

  BroadcastResultMsg(const BroadcastResultMsg& from);

  inline BroadcastResultMsg& operator=(const BroadcastResultMsg& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const BroadcastResultMsg& default_instance();

  void Swap(BroadcastResultMsg* other);

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

  BroadcastResultMsg* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const BroadcastResultMsg& from);
  void MergeFrom(const BroadcastResultMsg& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // required string hostName = 1;
  inline bool has_hostname() const;
  inline void clear_hostname();
  static const int kHostNameFieldNumber = 1;
  inline const ::std::string& hostname() const;
  inline void set_hostname(const ::std::string& value);
  inline void set_hostname(const char* value);
  inline void set_hostname(const char* value, size_t size);
  inline ::std::string* mutable_hostname();
  inline ::std::string* release_hostname();
  inline void set_allocated_hostname(::std::string* hostname);

  // required .kbd_idlfile.BroadcastTaskMsg task = 2;
  inline bool has_task() const;
  inline void clear_task();
  static const int kTaskFieldNumber = 2;
  inline const ::kbd_idlfile::BroadcastTaskMsg& task() const;
  inline ::kbd_idlfile::BroadcastTaskMsg* mutable_task();
  inline ::kbd_idlfile::BroadcastTaskMsg* release_task();
  inline void set_allocated_task(::kbd_idlfile::BroadcastTaskMsg* task);

  // required bool isSuccess = 3;
  inline bool has_issuccess() const;
  inline void clear_issuccess();
  static const int kIsSuccessFieldNumber = 3;
  inline bool issuccess() const;
  inline void set_issuccess(bool value);

  // required .kbd_idlfile.enTaskStatusType status = 4;
  inline bool has_status() const;
  inline void clear_status();
  static const int kStatusFieldNumber = 4;
  inline ::kbd_idlfile::enTaskStatusType status() const;
  inline void set_status(::kbd_idlfile::enTaskStatusType value);

  // required string resultStr = 5;
  inline bool has_resultstr() const;
  inline void clear_resultstr();
  static const int kResultStrFieldNumber = 5;
  inline const ::std::string& resultstr() const;
  inline void set_resultstr(const ::std::string& value);
  inline void set_resultstr(const char* value);
  inline void set_resultstr(const char* value, size_t size);
  inline ::std::string* mutable_resultstr();
  inline ::std::string* release_resultstr();
  inline void set_allocated_resultstr(::std::string* resultstr);

  // required int32 count = 6;
  inline bool has_count() const;
  inline void clear_count();
  static const int kCountFieldNumber = 6;
  inline ::google::protobuf::int32 count() const;
  inline void set_count(::google::protobuf::int32 value);

  // required int32 sendCount = 7;
  inline bool has_sendcount() const;
  inline void clear_sendcount();
  static const int kSendCountFieldNumber = 7;
  inline ::google::protobuf::int32 sendcount() const;
  inline void set_sendcount(::google::protobuf::int32 value);

  // required string pathFile = 8;
  inline bool has_pathfile() const;
  inline void clear_pathfile();
  static const int kPathFileFieldNumber = 8;
  inline const ::std::string& pathfile() const;
  inline void set_pathfile(const ::std::string& value);
  inline void set_pathfile(const char* value);
  inline void set_pathfile(const char* value, size_t size);
  inline ::std::string* mutable_pathfile();
  inline ::std::string* release_pathfile();
  inline void set_allocated_pathfile(::std::string* pathfile);

  // @@protoc_insertion_point(class_scope:kbd_idlfile.BroadcastResultMsg)
 private:
  inline void set_has_hostname();
  inline void clear_has_hostname();
  inline void set_has_task();
  inline void clear_has_task();
  inline void set_has_issuccess();
  inline void clear_has_issuccess();
  inline void set_has_status();
  inline void clear_has_status();
  inline void set_has_resultstr();
  inline void clear_has_resultstr();
  inline void set_has_count();
  inline void clear_has_count();
  inline void set_has_sendcount();
  inline void clear_has_sendcount();
  inline void set_has_pathfile();
  inline void clear_has_pathfile();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::std::string* hostname_;
  ::kbd_idlfile::BroadcastTaskMsg* task_;
  bool issuccess_;
  int status_;
  ::std::string* resultstr_;
  ::google::protobuf::int32 count_;
  ::google::protobuf::int32 sendcount_;
  ::std::string* pathfile_;
  friend void IDL_FILES_EXPORT protobuf_AddDesc_FileSynch_2eproto();
  friend void protobuf_AssignDesc_FileSynch_2eproto();
  friend void protobuf_ShutdownFile_FileSynch_2eproto();

  void InitAsDefaultInstance();
  static BroadcastResultMsg* default_instance_;
};
// ===================================================================


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

// DataBlock

// required uint64 index = 1;
inline bool DataBlock::has_index() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void DataBlock::set_has_index() {
  _has_bits_[0] |= 0x00000001u;
}
inline void DataBlock::clear_has_index() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void DataBlock::clear_index() {
  index_ = GOOGLE_ULONGLONG(0);
  clear_has_index();
}
inline ::google::protobuf::uint64 DataBlock::index() const {
  // @@protoc_insertion_point(field_get:kbd_idlfile.DataBlock.index)
  return index_;
}
inline void DataBlock::set_index(::google::protobuf::uint64 value) {
  set_has_index();
  index_ = value;
  // @@protoc_insertion_point(field_set:kbd_idlfile.DataBlock.index)
}

// required uint64 offset = 2;
inline bool DataBlock::has_offset() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void DataBlock::set_has_offset() {
  _has_bits_[0] |= 0x00000002u;
}
inline void DataBlock::clear_has_offset() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void DataBlock::clear_offset() {
  offset_ = GOOGLE_ULONGLONG(0);
  clear_has_offset();
}
inline ::google::protobuf::uint64 DataBlock::offset() const {
  // @@protoc_insertion_point(field_get:kbd_idlfile.DataBlock.offset)
  return offset_;
}
inline void DataBlock::set_offset(::google::protobuf::uint64 value) {
  set_has_offset();
  offset_ = value;
  // @@protoc_insertion_point(field_set:kbd_idlfile.DataBlock.offset)
}

// required uint64 len = 3;
inline bool DataBlock::has_len() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void DataBlock::set_has_len() {
  _has_bits_[0] |= 0x00000004u;
}
inline void DataBlock::clear_has_len() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void DataBlock::clear_len() {
  len_ = GOOGLE_ULONGLONG(0);
  clear_has_len();
}
inline ::google::protobuf::uint64 DataBlock::len() const {
  // @@protoc_insertion_point(field_get:kbd_idlfile.DataBlock.len)
  return len_;
}
inline void DataBlock::set_len(::google::protobuf::uint64 value) {
  set_has_len();
  len_ = value;
  // @@protoc_insertion_point(field_set:kbd_idlfile.DataBlock.len)
}

// required bytes buff = 4;
inline bool DataBlock::has_buff() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void DataBlock::set_has_buff() {
  _has_bits_[0] |= 0x00000008u;
}
inline void DataBlock::clear_has_buff() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void DataBlock::clear_buff() {
  if (buff_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    buff_->clear();
  }
  clear_has_buff();
}
inline const ::std::string& DataBlock::buff() const {
  // @@protoc_insertion_point(field_get:kbd_idlfile.DataBlock.buff)
  return *buff_;
}
inline void DataBlock::set_buff(const ::std::string& value) {
  set_has_buff();
  if (buff_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    buff_ = new ::std::string;
  }
  buff_->assign(value);
  // @@protoc_insertion_point(field_set:kbd_idlfile.DataBlock.buff)
}
inline void DataBlock::set_buff(const char* value) {
  set_has_buff();
  if (buff_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    buff_ = new ::std::string;
  }
  buff_->assign(value);
  // @@protoc_insertion_point(field_set_char:kbd_idlfile.DataBlock.buff)
}
inline void DataBlock::set_buff(const void* value, size_t size) {
  set_has_buff();
  if (buff_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    buff_ = new ::std::string;
  }
  buff_->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:kbd_idlfile.DataBlock.buff)
}
inline ::std::string* DataBlock::mutable_buff() {
  set_has_buff();
  if (buff_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    buff_ = new ::std::string;
  }
  // @@protoc_insertion_point(field_mutable:kbd_idlfile.DataBlock.buff)
  return buff_;
}
inline ::std::string* DataBlock::release_buff() {
  clear_has_buff();
  if (buff_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    return NULL;
  } else {
    ::std::string* temp = buff_;
    buff_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    return temp;
  }
}
inline void DataBlock::set_allocated_buff(::std::string* buff) {
  if (buff_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete buff_;
  }
  if (buff) {
    set_has_buff();
    buff_ = buff;
  } else {
    clear_has_buff();
    buff_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  // @@protoc_insertion_point(field_set_allocated:kbd_idlfile.DataBlock.buff)
}

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

// DataPack

// required string pathFile = 1;
inline bool DataPack::has_pathfile() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void DataPack::set_has_pathfile() {
  _has_bits_[0] |= 0x00000001u;
}
inline void DataPack::clear_has_pathfile() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void DataPack::clear_pathfile() {
  if (pathfile_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    pathfile_->clear();
  }
  clear_has_pathfile();
}
inline const ::std::string& DataPack::pathfile() const {
  // @@protoc_insertion_point(field_get:kbd_idlfile.DataPack.pathFile)
  return *pathfile_;
}
inline void DataPack::set_pathfile(const ::std::string& value) {
  set_has_pathfile();
  if (pathfile_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    pathfile_ = new ::std::string;
  }
  pathfile_->assign(value);
  // @@protoc_insertion_point(field_set:kbd_idlfile.DataPack.pathFile)
}
inline void DataPack::set_pathfile(const char* value) {
  set_has_pathfile();
  if (pathfile_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    pathfile_ = new ::std::string;
  }
  pathfile_->assign(value);
  // @@protoc_insertion_point(field_set_char:kbd_idlfile.DataPack.pathFile)
}
inline void DataPack::set_pathfile(const char* value, size_t size) {
  set_has_pathfile();
  if (pathfile_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    pathfile_ = new ::std::string;
  }
  pathfile_->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:kbd_idlfile.DataPack.pathFile)
}
inline ::std::string* DataPack::mutable_pathfile() {
  set_has_pathfile();
  if (pathfile_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    pathfile_ = new ::std::string;
  }
  // @@protoc_insertion_point(field_mutable:kbd_idlfile.DataPack.pathFile)
  return pathfile_;
}
inline ::std::string* DataPack::release_pathfile() {
  clear_has_pathfile();
  if (pathfile_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    return NULL;
  } else {
    ::std::string* temp = pathfile_;
    pathfile_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    return temp;
  }
}
inline void DataPack::set_allocated_pathfile(::std::string* pathfile) {
  if (pathfile_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete pathfile_;
  }
  if (pathfile) {
    set_has_pathfile();
    pathfile_ = pathfile;
  } else {
    clear_has_pathfile();
    pathfile_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  // @@protoc_insertion_point(field_set_allocated:kbd_idlfile.DataPack.pathFile)
}

// required uint64 blockCount = 2;
inline bool DataPack::has_blockcount() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void DataPack::set_has_blockcount() {
  _has_bits_[0] |= 0x00000002u;
}
inline void DataPack::clear_has_blockcount() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void DataPack::clear_blockcount() {
  blockcount_ = GOOGLE_ULONGLONG(0);
  clear_has_blockcount();
}
inline ::google::protobuf::uint64 DataPack::blockcount() const {
  // @@protoc_insertion_point(field_get:kbd_idlfile.DataPack.blockCount)
  return blockcount_;
}
inline void DataPack::set_blockcount(::google::protobuf::uint64 value) {
  set_has_blockcount();
  blockcount_ = value;
  // @@protoc_insertion_point(field_set:kbd_idlfile.DataPack.blockCount)
}

// required int32 isDir = 3;
inline bool DataPack::has_isdir() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void DataPack::set_has_isdir() {
  _has_bits_[0] |= 0x00000004u;
}
inline void DataPack::clear_has_isdir() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void DataPack::clear_isdir() {
  isdir_ = 0;
  clear_has_isdir();
}
inline ::google::protobuf::int32 DataPack::isdir() const {
  // @@protoc_insertion_point(field_get:kbd_idlfile.DataPack.isDir)
  return isdir_;
}
inline void DataPack::set_isdir(::google::protobuf::int32 value) {
  set_has_isdir();
  isdir_ = value;
  // @@protoc_insertion_point(field_set:kbd_idlfile.DataPack.isDir)
}

// required uint64 fileSize = 4;
inline bool DataPack::has_filesize() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void DataPack::set_has_filesize() {
  _has_bits_[0] |= 0x00000008u;
}
inline void DataPack::clear_has_filesize() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void DataPack::clear_filesize() {
  filesize_ = GOOGLE_ULONGLONG(0);
  clear_has_filesize();
}
inline ::google::protobuf::uint64 DataPack::filesize() const {
  // @@protoc_insertion_point(field_get:kbd_idlfile.DataPack.fileSize)
  return filesize_;
}
inline void DataPack::set_filesize(::google::protobuf::uint64 value) {
  set_has_filesize();
  filesize_ = value;
  // @@protoc_insertion_point(field_set:kbd_idlfile.DataPack.fileSize)
}

// required string checkCode = 5;
inline bool DataPack::has_checkcode() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void DataPack::set_has_checkcode() {
  _has_bits_[0] |= 0x00000010u;
}
inline void DataPack::clear_has_checkcode() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void DataPack::clear_checkcode() {
  if (checkcode_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    checkcode_->clear();
  }
  clear_has_checkcode();
}
inline const ::std::string& DataPack::checkcode() const {
  // @@protoc_insertion_point(field_get:kbd_idlfile.DataPack.checkCode)
  return *checkcode_;
}
inline void DataPack::set_checkcode(const ::std::string& value) {
  set_has_checkcode();
  if (checkcode_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    checkcode_ = new ::std::string;
  }
  checkcode_->assign(value);
  // @@protoc_insertion_point(field_set:kbd_idlfile.DataPack.checkCode)
}
inline void DataPack::set_checkcode(const char* value) {
  set_has_checkcode();
  if (checkcode_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    checkcode_ = new ::std::string;
  }
  checkcode_->assign(value);
  // @@protoc_insertion_point(field_set_char:kbd_idlfile.DataPack.checkCode)
}
inline void DataPack::set_checkcode(const char* value, size_t size) {
  set_has_checkcode();
  if (checkcode_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    checkcode_ = new ::std::string;
  }
  checkcode_->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:kbd_idlfile.DataPack.checkCode)
}
inline ::std::string* DataPack::mutable_checkcode() {
  set_has_checkcode();
  if (checkcode_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    checkcode_ = new ::std::string;
  }
  // @@protoc_insertion_point(field_mutable:kbd_idlfile.DataPack.checkCode)
  return checkcode_;
}
inline ::std::string* DataPack::release_checkcode() {
  clear_has_checkcode();
  if (checkcode_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    return NULL;
  } else {
    ::std::string* temp = checkcode_;
    checkcode_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    return temp;
  }
}
inline void DataPack::set_allocated_checkcode(::std::string* checkcode) {
  if (checkcode_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete checkcode_;
  }
  if (checkcode) {
    set_has_checkcode();
    checkcode_ = checkcode;
  } else {
    clear_has_checkcode();
    checkcode_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  // @@protoc_insertion_point(field_set_allocated:kbd_idlfile.DataPack.checkCode)
}

// optional .kbd_idlfile.DataBlock dataBlock = 6;
inline bool DataPack::has_datablock() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void DataPack::set_has_datablock() {
  _has_bits_[0] |= 0x00000020u;
}
inline void DataPack::clear_has_datablock() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void DataPack::clear_datablock() {
  if (datablock_ != NULL) datablock_->::kbd_idlfile::DataBlock::Clear();
  clear_has_datablock();
}
inline const ::kbd_idlfile::DataBlock& DataPack::datablock() const {
  // @@protoc_insertion_point(field_get:kbd_idlfile.DataPack.dataBlock)
  return datablock_ != NULL ? *datablock_ : *default_instance_->datablock_;
}
inline ::kbd_idlfile::DataBlock* DataPack::mutable_datablock() {
  set_has_datablock();
  if (datablock_ == NULL) datablock_ = new ::kbd_idlfile::DataBlock;
  // @@protoc_insertion_point(field_mutable:kbd_idlfile.DataPack.dataBlock)
  return datablock_;
}
inline ::kbd_idlfile::DataBlock* DataPack::release_datablock() {
  clear_has_datablock();
  ::kbd_idlfile::DataBlock* temp = datablock_;
  datablock_ = NULL;
  return temp;
}
inline void DataPack::set_allocated_datablock(::kbd_idlfile::DataBlock* datablock) {
  delete datablock_;
  datablock_ = datablock;
  if (datablock) {
    set_has_datablock();
  } else {
    clear_has_datablock();
  }
  // @@protoc_insertion_point(field_set_allocated:kbd_idlfile.DataPack.dataBlock)
}

// optional string renamePathFile = 7;
inline bool DataPack::has_renamepathfile() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void DataPack::set_has_renamepathfile() {
  _has_bits_[0] |= 0x00000040u;
}
inline void DataPack::clear_has_renamepathfile() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void DataPack::clear_renamepathfile() {
  if (renamepathfile_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    renamepathfile_->clear();
  }
  clear_has_renamepathfile();
}
inline const ::std::string& DataPack::renamepathfile() const {
  // @@protoc_insertion_point(field_get:kbd_idlfile.DataPack.renamePathFile)
  return *renamepathfile_;
}
inline void DataPack::set_renamepathfile(const ::std::string& value) {
  set_has_renamepathfile();
  if (renamepathfile_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    renamepathfile_ = new ::std::string;
  }
  renamepathfile_->assign(value);
  // @@protoc_insertion_point(field_set:kbd_idlfile.DataPack.renamePathFile)
}
inline void DataPack::set_renamepathfile(const char* value) {
  set_has_renamepathfile();
  if (renamepathfile_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    renamepathfile_ = new ::std::string;
  }
  renamepathfile_->assign(value);
  // @@protoc_insertion_point(field_set_char:kbd_idlfile.DataPack.renamePathFile)
}
inline void DataPack::set_renamepathfile(const char* value, size_t size) {
  set_has_renamepathfile();
  if (renamepathfile_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    renamepathfile_ = new ::std::string;
  }
  renamepathfile_->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:kbd_idlfile.DataPack.renamePathFile)
}
inline ::std::string* DataPack::mutable_renamepathfile() {
  set_has_renamepathfile();
  if (renamepathfile_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    renamepathfile_ = new ::std::string;
  }
  // @@protoc_insertion_point(field_mutable:kbd_idlfile.DataPack.renamePathFile)
  return renamepathfile_;
}
inline ::std::string* DataPack::release_renamepathfile() {
  clear_has_renamepathfile();
  if (renamepathfile_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    return NULL;
  } else {
    ::std::string* temp = renamepathfile_;
    renamepathfile_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    return temp;
  }
}
inline void DataPack::set_allocated_renamepathfile(::std::string* renamepathfile) {
  if (renamepathfile_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete renamepathfile_;
  }
  if (renamepathfile) {
    set_has_renamepathfile();
    renamepathfile_ = renamepathfile;
  } else {
    clear_has_renamepathfile();
    renamepathfile_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  // @@protoc_insertion_point(field_set_allocated:kbd_idlfile.DataPack.renamePathFile)
}

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

// FileNode

// required string pathFile = 1;
inline bool FileNode::has_pathfile() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void FileNode::set_has_pathfile() {
  _has_bits_[0] |= 0x00000001u;
}
inline void FileNode::clear_has_pathfile() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void FileNode::clear_pathfile() {
  if (pathfile_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    pathfile_->clear();
  }
  clear_has_pathfile();
}
inline const ::std::string& FileNode::pathfile() const {
  // @@protoc_insertion_point(field_get:kbd_idlfile.FileNode.pathFile)
  return *pathfile_;
}
inline void FileNode::set_pathfile(const ::std::string& value) {
  set_has_pathfile();
  if (pathfile_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    pathfile_ = new ::std::string;
  }
  pathfile_->assign(value);
  // @@protoc_insertion_point(field_set:kbd_idlfile.FileNode.pathFile)
}
inline void FileNode::set_pathfile(const char* value) {
  set_has_pathfile();
  if (pathfile_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    pathfile_ = new ::std::string;
  }
  pathfile_->assign(value);
  // @@protoc_insertion_point(field_set_char:kbd_idlfile.FileNode.pathFile)
}
inline void FileNode::set_pathfile(const char* value, size_t size) {
  set_has_pathfile();
  if (pathfile_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    pathfile_ = new ::std::string;
  }
  pathfile_->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:kbd_idlfile.FileNode.pathFile)
}
inline ::std::string* FileNode::mutable_pathfile() {
  set_has_pathfile();
  if (pathfile_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    pathfile_ = new ::std::string;
  }
  // @@protoc_insertion_point(field_mutable:kbd_idlfile.FileNode.pathFile)
  return pathfile_;
}
inline ::std::string* FileNode::release_pathfile() {
  clear_has_pathfile();
  if (pathfile_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    return NULL;
  } else {
    ::std::string* temp = pathfile_;
    pathfile_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    return temp;
  }
}
inline void FileNode::set_allocated_pathfile(::std::string* pathfile) {
  if (pathfile_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete pathfile_;
  }
  if (pathfile) {
    set_has_pathfile();
    pathfile_ = pathfile;
  } else {
    clear_has_pathfile();
    pathfile_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  // @@protoc_insertion_point(field_set_allocated:kbd_idlfile.FileNode.pathFile)
}

// required int32 isDir = 2;
inline bool FileNode::has_isdir() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void FileNode::set_has_isdir() {
  _has_bits_[0] |= 0x00000002u;
}
inline void FileNode::clear_has_isdir() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void FileNode::clear_isdir() {
  isdir_ = 0;
  clear_has_isdir();
}
inline ::google::protobuf::int32 FileNode::isdir() const {
  // @@protoc_insertion_point(field_get:kbd_idlfile.FileNode.isDir)
  return isdir_;
}
inline void FileNode::set_isdir(::google::protobuf::int32 value) {
  set_has_isdir();
  isdir_ = value;
  // @@protoc_insertion_point(field_set:kbd_idlfile.FileNode.isDir)
}

// required int32 isConfigPath = 3;
inline bool FileNode::has_isconfigpath() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void FileNode::set_has_isconfigpath() {
  _has_bits_[0] |= 0x00000004u;
}
inline void FileNode::clear_has_isconfigpath() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void FileNode::clear_isconfigpath() {
  isconfigpath_ = 0;
  clear_has_isconfigpath();
}
inline ::google::protobuf::int32 FileNode::isconfigpath() const {
  // @@protoc_insertion_point(field_get:kbd_idlfile.FileNode.isConfigPath)
  return isconfigpath_;
}
inline void FileNode::set_isconfigpath(::google::protobuf::int32 value) {
  set_has_isconfigpath();
  isconfigpath_ = value;
  // @@protoc_insertion_point(field_set:kbd_idlfile.FileNode.isConfigPath)
}

// optional uint64 fileSize = 4;
inline bool FileNode::has_filesize() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void FileNode::set_has_filesize() {
  _has_bits_[0] |= 0x00000008u;
}
inline void FileNode::clear_has_filesize() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void FileNode::clear_filesize() {
  filesize_ = GOOGLE_ULONGLONG(0);
  clear_has_filesize();
}
inline ::google::protobuf::uint64 FileNode::filesize() const {
  // @@protoc_insertion_point(field_get:kbd_idlfile.FileNode.fileSize)
  return filesize_;
}
inline void FileNode::set_filesize(::google::protobuf::uint64 value) {
  set_has_filesize();
  filesize_ = value;
  // @@protoc_insertion_point(field_set:kbd_idlfile.FileNode.fileSize)
}

// optional uint64 modifyTime = 5;
inline bool FileNode::has_modifytime() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void FileNode::set_has_modifytime() {
  _has_bits_[0] |= 0x00000010u;
}
inline void FileNode::clear_has_modifytime() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void FileNode::clear_modifytime() {
  modifytime_ = GOOGLE_ULONGLONG(0);
  clear_has_modifytime();
}
inline ::google::protobuf::uint64 FileNode::modifytime() const {
  // @@protoc_insertion_point(field_get:kbd_idlfile.FileNode.modifyTime)
  return modifytime_;
}
inline void FileNode::set_modifytime(::google::protobuf::uint64 value) {
  set_has_modifytime();
  modifytime_ = value;
  // @@protoc_insertion_point(field_set:kbd_idlfile.FileNode.modifyTime)
}

// repeated .kbd_idlfile.FileNode childNode = 6;
inline int FileNode::childnode_size() const {
  return childnode_.size();
}
inline void FileNode::clear_childnode() {
  childnode_.Clear();
}
inline const ::kbd_idlfile::FileNode& FileNode::childnode(int index) const {
  // @@protoc_insertion_point(field_get:kbd_idlfile.FileNode.childNode)
  return childnode_.Get(index);
}
inline ::kbd_idlfile::FileNode* FileNode::mutable_childnode(int index) {
  // @@protoc_insertion_point(field_mutable:kbd_idlfile.FileNode.childNode)
  return childnode_.Mutable(index);
}
inline ::kbd_idlfile::FileNode* FileNode::add_childnode() {
  // @@protoc_insertion_point(field_add:kbd_idlfile.FileNode.childNode)
  return childnode_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::kbd_idlfile::FileNode >&
FileNode::childnode() const {
  // @@protoc_insertion_point(field_list:kbd_idlfile.FileNode.childNode)
  return childnode_;
}
inline ::google::protobuf::RepeatedPtrField< ::kbd_idlfile::FileNode >*
FileNode::mutable_childnode() {
  // @@protoc_insertion_point(field_mutable_list:kbd_idlfile.FileNode.childNode)
  return &childnode_;
}

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

// FileNodeReqMsg

// required string hostName = 1;
inline bool FileNodeReqMsg::has_hostname() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void FileNodeReqMsg::set_has_hostname() {
  _has_bits_[0] |= 0x00000001u;
}
inline void FileNodeReqMsg::clear_has_hostname() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void FileNodeReqMsg::clear_hostname() {
  if (hostname_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    hostname_->clear();
  }
  clear_has_hostname();
}
inline const ::std::string& FileNodeReqMsg::hostname() const {
  // @@protoc_insertion_point(field_get:kbd_idlfile.FileNodeReqMsg.hostName)
  return *hostname_;
}
inline void FileNodeReqMsg::set_hostname(const ::std::string& value) {
  set_has_hostname();
  if (hostname_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    hostname_ = new ::std::string;
  }
  hostname_->assign(value);
  // @@protoc_insertion_point(field_set:kbd_idlfile.FileNodeReqMsg.hostName)
}
inline void FileNodeReqMsg::set_hostname(const char* value) {
  set_has_hostname();
  if (hostname_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    hostname_ = new ::std::string;
  }
  hostname_->assign(value);
  // @@protoc_insertion_point(field_set_char:kbd_idlfile.FileNodeReqMsg.hostName)
}
inline void FileNodeReqMsg::set_hostname(const char* value, size_t size) {
  set_has_hostname();
  if (hostname_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    hostname_ = new ::std::string;
  }
  hostname_->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:kbd_idlfile.FileNodeReqMsg.hostName)
}
inline ::std::string* FileNodeReqMsg::mutable_hostname() {
  set_has_hostname();
  if (hostname_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    hostname_ = new ::std::string;
  }
  // @@protoc_insertion_point(field_mutable:kbd_idlfile.FileNodeReqMsg.hostName)
  return hostname_;
}
inline ::std::string* FileNodeReqMsg::release_hostname() {
  clear_has_hostname();
  if (hostname_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    return NULL;
  } else {
    ::std::string* temp = hostname_;
    hostname_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    return temp;
  }
}
inline void FileNodeReqMsg::set_allocated_hostname(::std::string* hostname) {
  if (hostname_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete hostname_;
  }
  if (hostname) {
    set_has_hostname();
    hostname_ = hostname;
  } else {
    clear_has_hostname();
    hostname_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  // @@protoc_insertion_point(field_set_allocated:kbd_idlfile.FileNodeReqMsg.hostName)
}

// repeated string pathFile = 2;
inline int FileNodeReqMsg::pathfile_size() const {
  return pathfile_.size();
}
inline void FileNodeReqMsg::clear_pathfile() {
  pathfile_.Clear();
}
inline const ::std::string& FileNodeReqMsg::pathfile(int index) const {
  // @@protoc_insertion_point(field_get:kbd_idlfile.FileNodeReqMsg.pathFile)
  return pathfile_.Get(index);
}
inline ::std::string* FileNodeReqMsg::mutable_pathfile(int index) {
  // @@protoc_insertion_point(field_mutable:kbd_idlfile.FileNodeReqMsg.pathFile)
  return pathfile_.Mutable(index);
}
inline void FileNodeReqMsg::set_pathfile(int index, const ::std::string& value) {
  // @@protoc_insertion_point(field_set:kbd_idlfile.FileNodeReqMsg.pathFile)
  pathfile_.Mutable(index)->assign(value);
}
inline void FileNodeReqMsg::set_pathfile(int index, const char* value) {
  pathfile_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:kbd_idlfile.FileNodeReqMsg.pathFile)
}
inline void FileNodeReqMsg::set_pathfile(int index, const char* value, size_t size) {
  pathfile_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:kbd_idlfile.FileNodeReqMsg.pathFile)
}
inline ::std::string* FileNodeReqMsg::add_pathfile() {
  return pathfile_.Add();
}
inline void FileNodeReqMsg::add_pathfile(const ::std::string& value) {
  pathfile_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:kbd_idlfile.FileNodeReqMsg.pathFile)
}
inline void FileNodeReqMsg::add_pathfile(const char* value) {
  pathfile_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:kbd_idlfile.FileNodeReqMsg.pathFile)
}
inline void FileNodeReqMsg::add_pathfile(const char* value, size_t size) {
  pathfile_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:kbd_idlfile.FileNodeReqMsg.pathFile)
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
FileNodeReqMsg::pathfile() const {
  // @@protoc_insertion_point(field_list:kbd_idlfile.FileNodeReqMsg.pathFile)
  return pathfile_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
FileNodeReqMsg::mutable_pathfile() {
  // @@protoc_insertion_point(field_mutable_list:kbd_idlfile.FileNodeReqMsg.pathFile)
  return &pathfile_;
}

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

// FileNodeRespMsg

// required string hostName = 1;
inline bool FileNodeRespMsg::has_hostname() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void FileNodeRespMsg::set_has_hostname() {
  _has_bits_[0] |= 0x00000001u;
}
inline void FileNodeRespMsg::clear_has_hostname() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void FileNodeRespMsg::clear_hostname() {
  if (hostname_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    hostname_->clear();
  }
  clear_has_hostname();
}
inline const ::std::string& FileNodeRespMsg::hostname() const {
  // @@protoc_insertion_point(field_get:kbd_idlfile.FileNodeRespMsg.hostName)
  return *hostname_;
}
inline void FileNodeRespMsg::set_hostname(const ::std::string& value) {
  set_has_hostname();
  if (hostname_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    hostname_ = new ::std::string;
  }
  hostname_->assign(value);
  // @@protoc_insertion_point(field_set:kbd_idlfile.FileNodeRespMsg.hostName)
}
inline void FileNodeRespMsg::set_hostname(const char* value) {
  set_has_hostname();
  if (hostname_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    hostname_ = new ::std::string;
  }
  hostname_->assign(value);
  // @@protoc_insertion_point(field_set_char:kbd_idlfile.FileNodeRespMsg.hostName)
}
inline void FileNodeRespMsg::set_hostname(const char* value, size_t size) {
  set_has_hostname();
  if (hostname_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    hostname_ = new ::std::string;
  }
  hostname_->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:kbd_idlfile.FileNodeRespMsg.hostName)
}
inline ::std::string* FileNodeRespMsg::mutable_hostname() {
  set_has_hostname();
  if (hostname_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    hostname_ = new ::std::string;
  }
  // @@protoc_insertion_point(field_mutable:kbd_idlfile.FileNodeRespMsg.hostName)
  return hostname_;
}
inline ::std::string* FileNodeRespMsg::release_hostname() {
  clear_has_hostname();
  if (hostname_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    return NULL;
  } else {
    ::std::string* temp = hostname_;
    hostname_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    return temp;
  }
}
inline void FileNodeRespMsg::set_allocated_hostname(::std::string* hostname) {
  if (hostname_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete hostname_;
  }
  if (hostname) {
    set_has_hostname();
    hostname_ = hostname;
  } else {
    clear_has_hostname();
    hostname_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  // @@protoc_insertion_point(field_set_allocated:kbd_idlfile.FileNodeRespMsg.hostName)
}

// required int32 isRoot = 2;
inline bool FileNodeRespMsg::has_isroot() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void FileNodeRespMsg::set_has_isroot() {
  _has_bits_[0] |= 0x00000002u;
}
inline void FileNodeRespMsg::clear_has_isroot() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void FileNodeRespMsg::clear_isroot() {
  isroot_ = 0;
  clear_has_isroot();
}
inline ::google::protobuf::int32 FileNodeRespMsg::isroot() const {
  // @@protoc_insertion_point(field_get:kbd_idlfile.FileNodeRespMsg.isRoot)
  return isroot_;
}
inline void FileNodeRespMsg::set_isroot(::google::protobuf::int32 value) {
  set_has_isroot();
  isroot_ = value;
  // @@protoc_insertion_point(field_set:kbd_idlfile.FileNodeRespMsg.isRoot)
}

// repeated .kbd_idlfile.FileNode node = 3;
inline int FileNodeRespMsg::node_size() const {
  return node_.size();
}
inline void FileNodeRespMsg::clear_node() {
  node_.Clear();
}
inline const ::kbd_idlfile::FileNode& FileNodeRespMsg::node(int index) const {
  // @@protoc_insertion_point(field_get:kbd_idlfile.FileNodeRespMsg.node)
  return node_.Get(index);
}
inline ::kbd_idlfile::FileNode* FileNodeRespMsg::mutable_node(int index) {
  // @@protoc_insertion_point(field_mutable:kbd_idlfile.FileNodeRespMsg.node)
  return node_.Mutable(index);
}
inline ::kbd_idlfile::FileNode* FileNodeRespMsg::add_node() {
  // @@protoc_insertion_point(field_add:kbd_idlfile.FileNodeRespMsg.node)
  return node_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::kbd_idlfile::FileNode >&
FileNodeRespMsg::node() const {
  // @@protoc_insertion_point(field_list:kbd_idlfile.FileNodeRespMsg.node)
  return node_;
}
inline ::google::protobuf::RepeatedPtrField< ::kbd_idlfile::FileNode >*
FileNodeRespMsg::mutable_node() {
  // @@protoc_insertion_point(field_mutable_list:kbd_idlfile.FileNodeRespMsg.node)
  return &node_;
}

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

// FileChangeReqMsg

// required string hostName = 1;
inline bool FileChangeReqMsg::has_hostname() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void FileChangeReqMsg::set_has_hostname() {
  _has_bits_[0] |= 0x00000001u;
}
inline void FileChangeReqMsg::clear_has_hostname() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void FileChangeReqMsg::clear_hostname() {
  if (hostname_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    hostname_->clear();
  }
  clear_has_hostname();
}
inline const ::std::string& FileChangeReqMsg::hostname() const {
  // @@protoc_insertion_point(field_get:kbd_idlfile.FileChangeReqMsg.hostName)
  return *hostname_;
}
inline void FileChangeReqMsg::set_hostname(const ::std::string& value) {
  set_has_hostname();
  if (hostname_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    hostname_ = new ::std::string;
  }
  hostname_->assign(value);
  // @@protoc_insertion_point(field_set:kbd_idlfile.FileChangeReqMsg.hostName)
}
inline void FileChangeReqMsg::set_hostname(const char* value) {
  set_has_hostname();
  if (hostname_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    hostname_ = new ::std::string;
  }
  hostname_->assign(value);
  // @@protoc_insertion_point(field_set_char:kbd_idlfile.FileChangeReqMsg.hostName)
}
inline void FileChangeReqMsg::set_hostname(const char* value, size_t size) {
  set_has_hostname();
  if (hostname_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    hostname_ = new ::std::string;
  }
  hostname_->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:kbd_idlfile.FileChangeReqMsg.hostName)
}
inline ::std::string* FileChangeReqMsg::mutable_hostname() {
  set_has_hostname();
  if (hostname_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    hostname_ = new ::std::string;
  }
  // @@protoc_insertion_point(field_mutable:kbd_idlfile.FileChangeReqMsg.hostName)
  return hostname_;
}
inline ::std::string* FileChangeReqMsg::release_hostname() {
  clear_has_hostname();
  if (hostname_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    return NULL;
  } else {
    ::std::string* temp = hostname_;
    hostname_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    return temp;
  }
}
inline void FileChangeReqMsg::set_allocated_hostname(::std::string* hostname) {
  if (hostname_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete hostname_;
  }
  if (hostname) {
    set_has_hostname();
    hostname_ = hostname;
  } else {
    clear_has_hostname();
    hostname_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  // @@protoc_insertion_point(field_set_allocated:kbd_idlfile.FileChangeReqMsg.hostName)
}

// required int32 optType = 2;
inline bool FileChangeReqMsg::has_opttype() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void FileChangeReqMsg::set_has_opttype() {
  _has_bits_[0] |= 0x00000002u;
}
inline void FileChangeReqMsg::clear_has_opttype() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void FileChangeReqMsg::clear_opttype() {
  opttype_ = 0;
  clear_has_opttype();
}
inline ::google::protobuf::int32 FileChangeReqMsg::opttype() const {
  // @@protoc_insertion_point(field_get:kbd_idlfile.FileChangeReqMsg.optType)
  return opttype_;
}
inline void FileChangeReqMsg::set_opttype(::google::protobuf::int32 value) {
  set_has_opttype();
  opttype_ = value;
  // @@protoc_insertion_point(field_set:kbd_idlfile.FileChangeReqMsg.optType)
}

// required string pathFile = 3;
inline bool FileChangeReqMsg::has_pathfile() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void FileChangeReqMsg::set_has_pathfile() {
  _has_bits_[0] |= 0x00000004u;
}
inline void FileChangeReqMsg::clear_has_pathfile() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void FileChangeReqMsg::clear_pathfile() {
  if (pathfile_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    pathfile_->clear();
  }
  clear_has_pathfile();
}
inline const ::std::string& FileChangeReqMsg::pathfile() const {
  // @@protoc_insertion_point(field_get:kbd_idlfile.FileChangeReqMsg.pathFile)
  return *pathfile_;
}
inline void FileChangeReqMsg::set_pathfile(const ::std::string& value) {
  set_has_pathfile();
  if (pathfile_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    pathfile_ = new ::std::string;
  }
  pathfile_->assign(value);
  // @@protoc_insertion_point(field_set:kbd_idlfile.FileChangeReqMsg.pathFile)
}
inline void FileChangeReqMsg::set_pathfile(const char* value) {
  set_has_pathfile();
  if (pathfile_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    pathfile_ = new ::std::string;
  }
  pathfile_->assign(value);
  // @@protoc_insertion_point(field_set_char:kbd_idlfile.FileChangeReqMsg.pathFile)
}
inline void FileChangeReqMsg::set_pathfile(const char* value, size_t size) {
  set_has_pathfile();
  if (pathfile_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    pathfile_ = new ::std::string;
  }
  pathfile_->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:kbd_idlfile.FileChangeReqMsg.pathFile)
}
inline ::std::string* FileChangeReqMsg::mutable_pathfile() {
  set_has_pathfile();
  if (pathfile_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    pathfile_ = new ::std::string;
  }
  // @@protoc_insertion_point(field_mutable:kbd_idlfile.FileChangeReqMsg.pathFile)
  return pathfile_;
}
inline ::std::string* FileChangeReqMsg::release_pathfile() {
  clear_has_pathfile();
  if (pathfile_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    return NULL;
  } else {
    ::std::string* temp = pathfile_;
    pathfile_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    return temp;
  }
}
inline void FileChangeReqMsg::set_allocated_pathfile(::std::string* pathfile) {
  if (pathfile_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete pathfile_;
  }
  if (pathfile) {
    set_has_pathfile();
    pathfile_ = pathfile;
  } else {
    clear_has_pathfile();
    pathfile_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  // @@protoc_insertion_point(field_set_allocated:kbd_idlfile.FileChangeReqMsg.pathFile)
}

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

// FileChangeExeMsg

// required string hostName = 1;
inline bool FileChangeExeMsg::has_hostname() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void FileChangeExeMsg::set_has_hostname() {
  _has_bits_[0] |= 0x00000001u;
}
inline void FileChangeExeMsg::clear_has_hostname() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void FileChangeExeMsg::clear_hostname() {
  if (hostname_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    hostname_->clear();
  }
  clear_has_hostname();
}
inline const ::std::string& FileChangeExeMsg::hostname() const {
  // @@protoc_insertion_point(field_get:kbd_idlfile.FileChangeExeMsg.hostName)
  return *hostname_;
}
inline void FileChangeExeMsg::set_hostname(const ::std::string& value) {
  set_has_hostname();
  if (hostname_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    hostname_ = new ::std::string;
  }
  hostname_->assign(value);
  // @@protoc_insertion_point(field_set:kbd_idlfile.FileChangeExeMsg.hostName)
}
inline void FileChangeExeMsg::set_hostname(const char* value) {
  set_has_hostname();
  if (hostname_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    hostname_ = new ::std::string;
  }
  hostname_->assign(value);
  // @@protoc_insertion_point(field_set_char:kbd_idlfile.FileChangeExeMsg.hostName)
}
inline void FileChangeExeMsg::set_hostname(const char* value, size_t size) {
  set_has_hostname();
  if (hostname_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    hostname_ = new ::std::string;
  }
  hostname_->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:kbd_idlfile.FileChangeExeMsg.hostName)
}
inline ::std::string* FileChangeExeMsg::mutable_hostname() {
  set_has_hostname();
  if (hostname_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    hostname_ = new ::std::string;
  }
  // @@protoc_insertion_point(field_mutable:kbd_idlfile.FileChangeExeMsg.hostName)
  return hostname_;
}
inline ::std::string* FileChangeExeMsg::release_hostname() {
  clear_has_hostname();
  if (hostname_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    return NULL;
  } else {
    ::std::string* temp = hostname_;
    hostname_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    return temp;
  }
}
inline void FileChangeExeMsg::set_allocated_hostname(::std::string* hostname) {
  if (hostname_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete hostname_;
  }
  if (hostname) {
    set_has_hostname();
    hostname_ = hostname;
  } else {
    clear_has_hostname();
    hostname_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  // @@protoc_insertion_point(field_set_allocated:kbd_idlfile.FileChangeExeMsg.hostName)
}

// required int32 optType = 2;
inline bool FileChangeExeMsg::has_opttype() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void FileChangeExeMsg::set_has_opttype() {
  _has_bits_[0] |= 0x00000002u;
}
inline void FileChangeExeMsg::clear_has_opttype() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void FileChangeExeMsg::clear_opttype() {
  opttype_ = 0;
  clear_has_opttype();
}
inline ::google::protobuf::int32 FileChangeExeMsg::opttype() const {
  // @@protoc_insertion_point(field_get:kbd_idlfile.FileChangeExeMsg.optType)
  return opttype_;
}
inline void FileChangeExeMsg::set_opttype(::google::protobuf::int32 value) {
  set_has_opttype();
  opttype_ = value;
  // @@protoc_insertion_point(field_set:kbd_idlfile.FileChangeExeMsg.optType)
}

// required string pathFile = 3;
inline bool FileChangeExeMsg::has_pathfile() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void FileChangeExeMsg::set_has_pathfile() {
  _has_bits_[0] |= 0x00000004u;
}
inline void FileChangeExeMsg::clear_has_pathfile() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void FileChangeExeMsg::clear_pathfile() {
  if (pathfile_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    pathfile_->clear();
  }
  clear_has_pathfile();
}
inline const ::std::string& FileChangeExeMsg::pathfile() const {
  // @@protoc_insertion_point(field_get:kbd_idlfile.FileChangeExeMsg.pathFile)
  return *pathfile_;
}
inline void FileChangeExeMsg::set_pathfile(const ::std::string& value) {
  set_has_pathfile();
  if (pathfile_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    pathfile_ = new ::std::string;
  }
  pathfile_->assign(value);
  // @@protoc_insertion_point(field_set:kbd_idlfile.FileChangeExeMsg.pathFile)
}
inline void FileChangeExeMsg::set_pathfile(const char* value) {
  set_has_pathfile();
  if (pathfile_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    pathfile_ = new ::std::string;
  }
  pathfile_->assign(value);
  // @@protoc_insertion_point(field_set_char:kbd_idlfile.FileChangeExeMsg.pathFile)
}
inline void FileChangeExeMsg::set_pathfile(const char* value, size_t size) {
  set_has_pathfile();
  if (pathfile_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    pathfile_ = new ::std::string;
  }
  pathfile_->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:kbd_idlfile.FileChangeExeMsg.pathFile)
}
inline ::std::string* FileChangeExeMsg::mutable_pathfile() {
  set_has_pathfile();
  if (pathfile_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    pathfile_ = new ::std::string;
  }
  // @@protoc_insertion_point(field_mutable:kbd_idlfile.FileChangeExeMsg.pathFile)
  return pathfile_;
}
inline ::std::string* FileChangeExeMsg::release_pathfile() {
  clear_has_pathfile();
  if (pathfile_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    return NULL;
  } else {
    ::std::string* temp = pathfile_;
    pathfile_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    return temp;
  }
}
inline void FileChangeExeMsg::set_allocated_pathfile(::std::string* pathfile) {
  if (pathfile_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete pathfile_;
  }
  if (pathfile) {
    set_has_pathfile();
    pathfile_ = pathfile;
  } else {
    clear_has_pathfile();
    pathfile_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  // @@protoc_insertion_point(field_set_allocated:kbd_idlfile.FileChangeExeMsg.pathFile)
}

// required .kbd_idlfile.DataPack dataPack = 4;
inline bool FileChangeExeMsg::has_datapack() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void FileChangeExeMsg::set_has_datapack() {
  _has_bits_[0] |= 0x00000008u;
}
inline void FileChangeExeMsg::clear_has_datapack() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void FileChangeExeMsg::clear_datapack() {
  if (datapack_ != NULL) datapack_->::kbd_idlfile::DataPack::Clear();
  clear_has_datapack();
}
inline const ::kbd_idlfile::DataPack& FileChangeExeMsg::datapack() const {
  // @@protoc_insertion_point(field_get:kbd_idlfile.FileChangeExeMsg.dataPack)
  return datapack_ != NULL ? *datapack_ : *default_instance_->datapack_;
}
inline ::kbd_idlfile::DataPack* FileChangeExeMsg::mutable_datapack() {
  set_has_datapack();
  if (datapack_ == NULL) datapack_ = new ::kbd_idlfile::DataPack;
  // @@protoc_insertion_point(field_mutable:kbd_idlfile.FileChangeExeMsg.dataPack)
  return datapack_;
}
inline ::kbd_idlfile::DataPack* FileChangeExeMsg::release_datapack() {
  clear_has_datapack();
  ::kbd_idlfile::DataPack* temp = datapack_;
  datapack_ = NULL;
  return temp;
}
inline void FileChangeExeMsg::set_allocated_datapack(::kbd_idlfile::DataPack* datapack) {
  delete datapack_;
  datapack_ = datapack;
  if (datapack) {
    set_has_datapack();
  } else {
    clear_has_datapack();
  }
  // @@protoc_insertion_point(field_set_allocated:kbd_idlfile.FileChangeExeMsg.dataPack)
}

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

// BroadcastTaskMsg

// required string hostName = 1;
inline bool BroadcastTaskMsg::has_hostname() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void BroadcastTaskMsg::set_has_hostname() {
  _has_bits_[0] |= 0x00000001u;
}
inline void BroadcastTaskMsg::clear_has_hostname() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void BroadcastTaskMsg::clear_hostname() {
  if (hostname_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    hostname_->clear();
  }
  clear_has_hostname();
}
inline const ::std::string& BroadcastTaskMsg::hostname() const {
  // @@protoc_insertion_point(field_get:kbd_idlfile.BroadcastTaskMsg.hostName)
  return *hostname_;
}
inline void BroadcastTaskMsg::set_hostname(const ::std::string& value) {
  set_has_hostname();
  if (hostname_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    hostname_ = new ::std::string;
  }
  hostname_->assign(value);
  // @@protoc_insertion_point(field_set:kbd_idlfile.BroadcastTaskMsg.hostName)
}
inline void BroadcastTaskMsg::set_hostname(const char* value) {
  set_has_hostname();
  if (hostname_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    hostname_ = new ::std::string;
  }
  hostname_->assign(value);
  // @@protoc_insertion_point(field_set_char:kbd_idlfile.BroadcastTaskMsg.hostName)
}
inline void BroadcastTaskMsg::set_hostname(const char* value, size_t size) {
  set_has_hostname();
  if (hostname_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    hostname_ = new ::std::string;
  }
  hostname_->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:kbd_idlfile.BroadcastTaskMsg.hostName)
}
inline ::std::string* BroadcastTaskMsg::mutable_hostname() {
  set_has_hostname();
  if (hostname_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    hostname_ = new ::std::string;
  }
  // @@protoc_insertion_point(field_mutable:kbd_idlfile.BroadcastTaskMsg.hostName)
  return hostname_;
}
inline ::std::string* BroadcastTaskMsg::release_hostname() {
  clear_has_hostname();
  if (hostname_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    return NULL;
  } else {
    ::std::string* temp = hostname_;
    hostname_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    return temp;
  }
}
inline void BroadcastTaskMsg::set_allocated_hostname(::std::string* hostname) {
  if (hostname_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete hostname_;
  }
  if (hostname) {
    set_has_hostname();
    hostname_ = hostname;
  } else {
    clear_has_hostname();
    hostname_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  // @@protoc_insertion_point(field_set_allocated:kbd_idlfile.BroadcastTaskMsg.hostName)
}

// required string recvHostName = 2;
inline bool BroadcastTaskMsg::has_recvhostname() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void BroadcastTaskMsg::set_has_recvhostname() {
  _has_bits_[0] |= 0x00000002u;
}
inline void BroadcastTaskMsg::clear_has_recvhostname() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void BroadcastTaskMsg::clear_recvhostname() {
  if (recvhostname_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    recvhostname_->clear();
  }
  clear_has_recvhostname();
}
inline const ::std::string& BroadcastTaskMsg::recvhostname() const {
  // @@protoc_insertion_point(field_get:kbd_idlfile.BroadcastTaskMsg.recvHostName)
  return *recvhostname_;
}
inline void BroadcastTaskMsg::set_recvhostname(const ::std::string& value) {
  set_has_recvhostname();
  if (recvhostname_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    recvhostname_ = new ::std::string;
  }
  recvhostname_->assign(value);
  // @@protoc_insertion_point(field_set:kbd_idlfile.BroadcastTaskMsg.recvHostName)
}
inline void BroadcastTaskMsg::set_recvhostname(const char* value) {
  set_has_recvhostname();
  if (recvhostname_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    recvhostname_ = new ::std::string;
  }
  recvhostname_->assign(value);
  // @@protoc_insertion_point(field_set_char:kbd_idlfile.BroadcastTaskMsg.recvHostName)
}
inline void BroadcastTaskMsg::set_recvhostname(const char* value, size_t size) {
  set_has_recvhostname();
  if (recvhostname_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    recvhostname_ = new ::std::string;
  }
  recvhostname_->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:kbd_idlfile.BroadcastTaskMsg.recvHostName)
}
inline ::std::string* BroadcastTaskMsg::mutable_recvhostname() {
  set_has_recvhostname();
  if (recvhostname_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    recvhostname_ = new ::std::string;
  }
  // @@protoc_insertion_point(field_mutable:kbd_idlfile.BroadcastTaskMsg.recvHostName)
  return recvhostname_;
}
inline ::std::string* BroadcastTaskMsg::release_recvhostname() {
  clear_has_recvhostname();
  if (recvhostname_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    return NULL;
  } else {
    ::std::string* temp = recvhostname_;
    recvhostname_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    return temp;
  }
}
inline void BroadcastTaskMsg::set_allocated_recvhostname(::std::string* recvhostname) {
  if (recvhostname_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete recvhostname_;
  }
  if (recvhostname) {
    set_has_recvhostname();
    recvhostname_ = recvhostname;
  } else {
    clear_has_recvhostname();
    recvhostname_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  // @@protoc_insertion_point(field_set_allocated:kbd_idlfile.BroadcastTaskMsg.recvHostName)
}

// required uint64 taskTime = 3;
inline bool BroadcastTaskMsg::has_tasktime() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void BroadcastTaskMsg::set_has_tasktime() {
  _has_bits_[0] |= 0x00000004u;
}
inline void BroadcastTaskMsg::clear_has_tasktime() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void BroadcastTaskMsg::clear_tasktime() {
  tasktime_ = GOOGLE_ULONGLONG(0);
  clear_has_tasktime();
}
inline ::google::protobuf::uint64 BroadcastTaskMsg::tasktime() const {
  // @@protoc_insertion_point(field_get:kbd_idlfile.BroadcastTaskMsg.taskTime)
  return tasktime_;
}
inline void BroadcastTaskMsg::set_tasktime(::google::protobuf::uint64 value) {
  set_has_tasktime();
  tasktime_ = value;
  // @@protoc_insertion_point(field_set:kbd_idlfile.BroadcastTaskMsg.taskTime)
}

// repeated string pathFile = 4;
inline int BroadcastTaskMsg::pathfile_size() const {
  return pathfile_.size();
}
inline void BroadcastTaskMsg::clear_pathfile() {
  pathfile_.Clear();
}
inline const ::std::string& BroadcastTaskMsg::pathfile(int index) const {
  // @@protoc_insertion_point(field_get:kbd_idlfile.BroadcastTaskMsg.pathFile)
  return pathfile_.Get(index);
}
inline ::std::string* BroadcastTaskMsg::mutable_pathfile(int index) {
  // @@protoc_insertion_point(field_mutable:kbd_idlfile.BroadcastTaskMsg.pathFile)
  return pathfile_.Mutable(index);
}
inline void BroadcastTaskMsg::set_pathfile(int index, const ::std::string& value) {
  // @@protoc_insertion_point(field_set:kbd_idlfile.BroadcastTaskMsg.pathFile)
  pathfile_.Mutable(index)->assign(value);
}
inline void BroadcastTaskMsg::set_pathfile(int index, const char* value) {
  pathfile_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:kbd_idlfile.BroadcastTaskMsg.pathFile)
}
inline void BroadcastTaskMsg::set_pathfile(int index, const char* value, size_t size) {
  pathfile_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:kbd_idlfile.BroadcastTaskMsg.pathFile)
}
inline ::std::string* BroadcastTaskMsg::add_pathfile() {
  return pathfile_.Add();
}
inline void BroadcastTaskMsg::add_pathfile(const ::std::string& value) {
  pathfile_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:kbd_idlfile.BroadcastTaskMsg.pathFile)
}
inline void BroadcastTaskMsg::add_pathfile(const char* value) {
  pathfile_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:kbd_idlfile.BroadcastTaskMsg.pathFile)
}
inline void BroadcastTaskMsg::add_pathfile(const char* value, size_t size) {
  pathfile_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:kbd_idlfile.BroadcastTaskMsg.pathFile)
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
BroadcastTaskMsg::pathfile() const {
  // @@protoc_insertion_point(field_list:kbd_idlfile.BroadcastTaskMsg.pathFile)
  return pathfile_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
BroadcastTaskMsg::mutable_pathfile() {
  // @@protoc_insertion_point(field_mutable_list:kbd_idlfile.BroadcastTaskMsg.pathFile)
  return &pathfile_;
}

// required .kbd_idlfile.enTaskType operate = 5;
inline bool BroadcastTaskMsg::has_operate() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void BroadcastTaskMsg::set_has_operate() {
  _has_bits_[0] |= 0x00000010u;
}
inline void BroadcastTaskMsg::clear_has_operate() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void BroadcastTaskMsg::clear_operate() {
  operate_ = 0;
  clear_has_operate();
}
inline ::kbd_idlfile::enTaskType BroadcastTaskMsg::operate() const {
  // @@protoc_insertion_point(field_get:kbd_idlfile.BroadcastTaskMsg.operate)
  return static_cast< ::kbd_idlfile::enTaskType >(operate_);
}
inline void BroadcastTaskMsg::set_operate(::kbd_idlfile::enTaskType value) {
  assert(::kbd_idlfile::enTaskType_IsValid(value));
  set_has_operate();
  operate_ = value;
  // @@protoc_insertion_point(field_set:kbd_idlfile.BroadcastTaskMsg.operate)
}

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

// ExeBroadcastMsg

// required string hostName = 1;
inline bool ExeBroadcastMsg::has_hostname() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ExeBroadcastMsg::set_has_hostname() {
  _has_bits_[0] |= 0x00000001u;
}
inline void ExeBroadcastMsg::clear_has_hostname() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void ExeBroadcastMsg::clear_hostname() {
  if (hostname_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    hostname_->clear();
  }
  clear_has_hostname();
}
inline const ::std::string& ExeBroadcastMsg::hostname() const {
  // @@protoc_insertion_point(field_get:kbd_idlfile.ExeBroadcastMsg.hostName)
  return *hostname_;
}
inline void ExeBroadcastMsg::set_hostname(const ::std::string& value) {
  set_has_hostname();
  if (hostname_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    hostname_ = new ::std::string;
  }
  hostname_->assign(value);
  // @@protoc_insertion_point(field_set:kbd_idlfile.ExeBroadcastMsg.hostName)
}
inline void ExeBroadcastMsg::set_hostname(const char* value) {
  set_has_hostname();
  if (hostname_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    hostname_ = new ::std::string;
  }
  hostname_->assign(value);
  // @@protoc_insertion_point(field_set_char:kbd_idlfile.ExeBroadcastMsg.hostName)
}
inline void ExeBroadcastMsg::set_hostname(const char* value, size_t size) {
  set_has_hostname();
  if (hostname_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    hostname_ = new ::std::string;
  }
  hostname_->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:kbd_idlfile.ExeBroadcastMsg.hostName)
}
inline ::std::string* ExeBroadcastMsg::mutable_hostname() {
  set_has_hostname();
  if (hostname_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    hostname_ = new ::std::string;
  }
  // @@protoc_insertion_point(field_mutable:kbd_idlfile.ExeBroadcastMsg.hostName)
  return hostname_;
}
inline ::std::string* ExeBroadcastMsg::release_hostname() {
  clear_has_hostname();
  if (hostname_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    return NULL;
  } else {
    ::std::string* temp = hostname_;
    hostname_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    return temp;
  }
}
inline void ExeBroadcastMsg::set_allocated_hostname(::std::string* hostname) {
  if (hostname_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete hostname_;
  }
  if (hostname) {
    set_has_hostname();
    hostname_ = hostname;
  } else {
    clear_has_hostname();
    hostname_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  // @@protoc_insertion_point(field_set_allocated:kbd_idlfile.ExeBroadcastMsg.hostName)
}

// required .kbd_idlfile.BroadcastTaskMsg task = 2;
inline bool ExeBroadcastMsg::has_task() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ExeBroadcastMsg::set_has_task() {
  _has_bits_[0] |= 0x00000002u;
}
inline void ExeBroadcastMsg::clear_has_task() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void ExeBroadcastMsg::clear_task() {
  if (task_ != NULL) task_->::kbd_idlfile::BroadcastTaskMsg::Clear();
  clear_has_task();
}
inline const ::kbd_idlfile::BroadcastTaskMsg& ExeBroadcastMsg::task() const {
  // @@protoc_insertion_point(field_get:kbd_idlfile.ExeBroadcastMsg.task)
  return task_ != NULL ? *task_ : *default_instance_->task_;
}
inline ::kbd_idlfile::BroadcastTaskMsg* ExeBroadcastMsg::mutable_task() {
  set_has_task();
  if (task_ == NULL) task_ = new ::kbd_idlfile::BroadcastTaskMsg;
  // @@protoc_insertion_point(field_mutable:kbd_idlfile.ExeBroadcastMsg.task)
  return task_;
}
inline ::kbd_idlfile::BroadcastTaskMsg* ExeBroadcastMsg::release_task() {
  clear_has_task();
  ::kbd_idlfile::BroadcastTaskMsg* temp = task_;
  task_ = NULL;
  return temp;
}
inline void ExeBroadcastMsg::set_allocated_task(::kbd_idlfile::BroadcastTaskMsg* task) {
  delete task_;
  task_ = task;
  if (task) {
    set_has_task();
  } else {
    clear_has_task();
  }
  // @@protoc_insertion_point(field_set_allocated:kbd_idlfile.ExeBroadcastMsg.task)
}

// required uint64 taskTime = 3;
inline bool ExeBroadcastMsg::has_tasktime() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void ExeBroadcastMsg::set_has_tasktime() {
  _has_bits_[0] |= 0x00000004u;
}
inline void ExeBroadcastMsg::clear_has_tasktime() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void ExeBroadcastMsg::clear_tasktime() {
  tasktime_ = GOOGLE_ULONGLONG(0);
  clear_has_tasktime();
}
inline ::google::protobuf::uint64 ExeBroadcastMsg::tasktime() const {
  // @@protoc_insertion_point(field_get:kbd_idlfile.ExeBroadcastMsg.taskTime)
  return tasktime_;
}
inline void ExeBroadcastMsg::set_tasktime(::google::protobuf::uint64 value) {
  set_has_tasktime();
  tasktime_ = value;
  // @@protoc_insertion_point(field_set:kbd_idlfile.ExeBroadcastMsg.taskTime)
}

// required int32 count = 4;
inline bool ExeBroadcastMsg::has_count() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void ExeBroadcastMsg::set_has_count() {
  _has_bits_[0] |= 0x00000008u;
}
inline void ExeBroadcastMsg::clear_has_count() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void ExeBroadcastMsg::clear_count() {
  count_ = 0;
  clear_has_count();
}
inline ::google::protobuf::int32 ExeBroadcastMsg::count() const {
  // @@protoc_insertion_point(field_get:kbd_idlfile.ExeBroadcastMsg.count)
  return count_;
}
inline void ExeBroadcastMsg::set_count(::google::protobuf::int32 value) {
  set_has_count();
  count_ = value;
  // @@protoc_insertion_point(field_set:kbd_idlfile.ExeBroadcastMsg.count)
}

// required int32 sendCount = 5;
inline bool ExeBroadcastMsg::has_sendcount() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void ExeBroadcastMsg::set_has_sendcount() {
  _has_bits_[0] |= 0x00000010u;
}
inline void ExeBroadcastMsg::clear_has_sendcount() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void ExeBroadcastMsg::clear_sendcount() {
  sendcount_ = 0;
  clear_has_sendcount();
}
inline ::google::protobuf::int32 ExeBroadcastMsg::sendcount() const {
  // @@protoc_insertion_point(field_get:kbd_idlfile.ExeBroadcastMsg.sendCount)
  return sendcount_;
}
inline void ExeBroadcastMsg::set_sendcount(::google::protobuf::int32 value) {
  set_has_sendcount();
  sendcount_ = value;
  // @@protoc_insertion_point(field_set:kbd_idlfile.ExeBroadcastMsg.sendCount)
}

// optional .kbd_idlfile.FileNode node = 6;
inline bool ExeBroadcastMsg::has_node() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void ExeBroadcastMsg::set_has_node() {
  _has_bits_[0] |= 0x00000020u;
}
inline void ExeBroadcastMsg::clear_has_node() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void ExeBroadcastMsg::clear_node() {
  if (node_ != NULL) node_->::kbd_idlfile::FileNode::Clear();
  clear_has_node();
}
inline const ::kbd_idlfile::FileNode& ExeBroadcastMsg::node() const {
  // @@protoc_insertion_point(field_get:kbd_idlfile.ExeBroadcastMsg.node)
  return node_ != NULL ? *node_ : *default_instance_->node_;
}
inline ::kbd_idlfile::FileNode* ExeBroadcastMsg::mutable_node() {
  set_has_node();
  if (node_ == NULL) node_ = new ::kbd_idlfile::FileNode;
  // @@protoc_insertion_point(field_mutable:kbd_idlfile.ExeBroadcastMsg.node)
  return node_;
}
inline ::kbd_idlfile::FileNode* ExeBroadcastMsg::release_node() {
  clear_has_node();
  ::kbd_idlfile::FileNode* temp = node_;
  node_ = NULL;
  return temp;
}
inline void ExeBroadcastMsg::set_allocated_node(::kbd_idlfile::FileNode* node) {
  delete node_;
  node_ = node;
  if (node) {
    set_has_node();
  } else {
    clear_has_node();
  }
  // @@protoc_insertion_point(field_set_allocated:kbd_idlfile.ExeBroadcastMsg.node)
}

// optional .kbd_idlfile.DataPack dataPack = 7;
inline bool ExeBroadcastMsg::has_datapack() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void ExeBroadcastMsg::set_has_datapack() {
  _has_bits_[0] |= 0x00000040u;
}
inline void ExeBroadcastMsg::clear_has_datapack() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void ExeBroadcastMsg::clear_datapack() {
  if (datapack_ != NULL) datapack_->::kbd_idlfile::DataPack::Clear();
  clear_has_datapack();
}
inline const ::kbd_idlfile::DataPack& ExeBroadcastMsg::datapack() const {
  // @@protoc_insertion_point(field_get:kbd_idlfile.ExeBroadcastMsg.dataPack)
  return datapack_ != NULL ? *datapack_ : *default_instance_->datapack_;
}
inline ::kbd_idlfile::DataPack* ExeBroadcastMsg::mutable_datapack() {
  set_has_datapack();
  if (datapack_ == NULL) datapack_ = new ::kbd_idlfile::DataPack;
  // @@protoc_insertion_point(field_mutable:kbd_idlfile.ExeBroadcastMsg.dataPack)
  return datapack_;
}
inline ::kbd_idlfile::DataPack* ExeBroadcastMsg::release_datapack() {
  clear_has_datapack();
  ::kbd_idlfile::DataPack* temp = datapack_;
  datapack_ = NULL;
  return temp;
}
inline void ExeBroadcastMsg::set_allocated_datapack(::kbd_idlfile::DataPack* datapack) {
  delete datapack_;
  datapack_ = datapack;
  if (datapack) {
    set_has_datapack();
  } else {
    clear_has_datapack();
  }
  // @@protoc_insertion_point(field_set_allocated:kbd_idlfile.ExeBroadcastMsg.dataPack)
}

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

// BroadcastResultMsg

// required string hostName = 1;
inline bool BroadcastResultMsg::has_hostname() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void BroadcastResultMsg::set_has_hostname() {
  _has_bits_[0] |= 0x00000001u;
}
inline void BroadcastResultMsg::clear_has_hostname() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void BroadcastResultMsg::clear_hostname() {
  if (hostname_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    hostname_->clear();
  }
  clear_has_hostname();
}
inline const ::std::string& BroadcastResultMsg::hostname() const {
  // @@protoc_insertion_point(field_get:kbd_idlfile.BroadcastResultMsg.hostName)
  return *hostname_;
}
inline void BroadcastResultMsg::set_hostname(const ::std::string& value) {
  set_has_hostname();
  if (hostname_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    hostname_ = new ::std::string;
  }
  hostname_->assign(value);
  // @@protoc_insertion_point(field_set:kbd_idlfile.BroadcastResultMsg.hostName)
}
inline void BroadcastResultMsg::set_hostname(const char* value) {
  set_has_hostname();
  if (hostname_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    hostname_ = new ::std::string;
  }
  hostname_->assign(value);
  // @@protoc_insertion_point(field_set_char:kbd_idlfile.BroadcastResultMsg.hostName)
}
inline void BroadcastResultMsg::set_hostname(const char* value, size_t size) {
  set_has_hostname();
  if (hostname_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    hostname_ = new ::std::string;
  }
  hostname_->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:kbd_idlfile.BroadcastResultMsg.hostName)
}
inline ::std::string* BroadcastResultMsg::mutable_hostname() {
  set_has_hostname();
  if (hostname_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    hostname_ = new ::std::string;
  }
  // @@protoc_insertion_point(field_mutable:kbd_idlfile.BroadcastResultMsg.hostName)
  return hostname_;
}
inline ::std::string* BroadcastResultMsg::release_hostname() {
  clear_has_hostname();
  if (hostname_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    return NULL;
  } else {
    ::std::string* temp = hostname_;
    hostname_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    return temp;
  }
}
inline void BroadcastResultMsg::set_allocated_hostname(::std::string* hostname) {
  if (hostname_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete hostname_;
  }
  if (hostname) {
    set_has_hostname();
    hostname_ = hostname;
  } else {
    clear_has_hostname();
    hostname_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  // @@protoc_insertion_point(field_set_allocated:kbd_idlfile.BroadcastResultMsg.hostName)
}

// required .kbd_idlfile.BroadcastTaskMsg task = 2;
inline bool BroadcastResultMsg::has_task() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void BroadcastResultMsg::set_has_task() {
  _has_bits_[0] |= 0x00000002u;
}
inline void BroadcastResultMsg::clear_has_task() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void BroadcastResultMsg::clear_task() {
  if (task_ != NULL) task_->::kbd_idlfile::BroadcastTaskMsg::Clear();
  clear_has_task();
}
inline const ::kbd_idlfile::BroadcastTaskMsg& BroadcastResultMsg::task() const {
  // @@protoc_insertion_point(field_get:kbd_idlfile.BroadcastResultMsg.task)
  return task_ != NULL ? *task_ : *default_instance_->task_;
}
inline ::kbd_idlfile::BroadcastTaskMsg* BroadcastResultMsg::mutable_task() {
  set_has_task();
  if (task_ == NULL) task_ = new ::kbd_idlfile::BroadcastTaskMsg;
  // @@protoc_insertion_point(field_mutable:kbd_idlfile.BroadcastResultMsg.task)
  return task_;
}
inline ::kbd_idlfile::BroadcastTaskMsg* BroadcastResultMsg::release_task() {
  clear_has_task();
  ::kbd_idlfile::BroadcastTaskMsg* temp = task_;
  task_ = NULL;
  return temp;
}
inline void BroadcastResultMsg::set_allocated_task(::kbd_idlfile::BroadcastTaskMsg* task) {
  delete task_;
  task_ = task;
  if (task) {
    set_has_task();
  } else {
    clear_has_task();
  }
  // @@protoc_insertion_point(field_set_allocated:kbd_idlfile.BroadcastResultMsg.task)
}

// required bool isSuccess = 3;
inline bool BroadcastResultMsg::has_issuccess() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void BroadcastResultMsg::set_has_issuccess() {
  _has_bits_[0] |= 0x00000004u;
}
inline void BroadcastResultMsg::clear_has_issuccess() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void BroadcastResultMsg::clear_issuccess() {
  issuccess_ = false;
  clear_has_issuccess();
}
inline bool BroadcastResultMsg::issuccess() const {
  // @@protoc_insertion_point(field_get:kbd_idlfile.BroadcastResultMsg.isSuccess)
  return issuccess_;
}
inline void BroadcastResultMsg::set_issuccess(bool value) {
  set_has_issuccess();
  issuccess_ = value;
  // @@protoc_insertion_point(field_set:kbd_idlfile.BroadcastResultMsg.isSuccess)
}

// required .kbd_idlfile.enTaskStatusType status = 4;
inline bool BroadcastResultMsg::has_status() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void BroadcastResultMsg::set_has_status() {
  _has_bits_[0] |= 0x00000008u;
}
inline void BroadcastResultMsg::clear_has_status() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void BroadcastResultMsg::clear_status() {
  status_ = 1;
  clear_has_status();
}
inline ::kbd_idlfile::enTaskStatusType BroadcastResultMsg::status() const {
  // @@protoc_insertion_point(field_get:kbd_idlfile.BroadcastResultMsg.status)
  return static_cast< ::kbd_idlfile::enTaskStatusType >(status_);
}
inline void BroadcastResultMsg::set_status(::kbd_idlfile::enTaskStatusType value) {
  assert(::kbd_idlfile::enTaskStatusType_IsValid(value));
  set_has_status();
  status_ = value;
  // @@protoc_insertion_point(field_set:kbd_idlfile.BroadcastResultMsg.status)
}

// required string resultStr = 5;
inline bool BroadcastResultMsg::has_resultstr() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void BroadcastResultMsg::set_has_resultstr() {
  _has_bits_[0] |= 0x00000010u;
}
inline void BroadcastResultMsg::clear_has_resultstr() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void BroadcastResultMsg::clear_resultstr() {
  if (resultstr_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    resultstr_->clear();
  }
  clear_has_resultstr();
}
inline const ::std::string& BroadcastResultMsg::resultstr() const {
  // @@protoc_insertion_point(field_get:kbd_idlfile.BroadcastResultMsg.resultStr)
  return *resultstr_;
}
inline void BroadcastResultMsg::set_resultstr(const ::std::string& value) {
  set_has_resultstr();
  if (resultstr_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    resultstr_ = new ::std::string;
  }
  resultstr_->assign(value);
  // @@protoc_insertion_point(field_set:kbd_idlfile.BroadcastResultMsg.resultStr)
}
inline void BroadcastResultMsg::set_resultstr(const char* value) {
  set_has_resultstr();
  if (resultstr_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    resultstr_ = new ::std::string;
  }
  resultstr_->assign(value);
  // @@protoc_insertion_point(field_set_char:kbd_idlfile.BroadcastResultMsg.resultStr)
}
inline void BroadcastResultMsg::set_resultstr(const char* value, size_t size) {
  set_has_resultstr();
  if (resultstr_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    resultstr_ = new ::std::string;
  }
  resultstr_->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:kbd_idlfile.BroadcastResultMsg.resultStr)
}
inline ::std::string* BroadcastResultMsg::mutable_resultstr() {
  set_has_resultstr();
  if (resultstr_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    resultstr_ = new ::std::string;
  }
  // @@protoc_insertion_point(field_mutable:kbd_idlfile.BroadcastResultMsg.resultStr)
  return resultstr_;
}
inline ::std::string* BroadcastResultMsg::release_resultstr() {
  clear_has_resultstr();
  if (resultstr_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    return NULL;
  } else {
    ::std::string* temp = resultstr_;
    resultstr_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    return temp;
  }
}
inline void BroadcastResultMsg::set_allocated_resultstr(::std::string* resultstr) {
  if (resultstr_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete resultstr_;
  }
  if (resultstr) {
    set_has_resultstr();
    resultstr_ = resultstr;
  } else {
    clear_has_resultstr();
    resultstr_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  // @@protoc_insertion_point(field_set_allocated:kbd_idlfile.BroadcastResultMsg.resultStr)
}

// required int32 count = 6;
inline bool BroadcastResultMsg::has_count() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void BroadcastResultMsg::set_has_count() {
  _has_bits_[0] |= 0x00000020u;
}
inline void BroadcastResultMsg::clear_has_count() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void BroadcastResultMsg::clear_count() {
  count_ = 0;
  clear_has_count();
}
inline ::google::protobuf::int32 BroadcastResultMsg::count() const {
  // @@protoc_insertion_point(field_get:kbd_idlfile.BroadcastResultMsg.count)
  return count_;
}
inline void BroadcastResultMsg::set_count(::google::protobuf::int32 value) {
  set_has_count();
  count_ = value;
  // @@protoc_insertion_point(field_set:kbd_idlfile.BroadcastResultMsg.count)
}

// required int32 sendCount = 7;
inline bool BroadcastResultMsg::has_sendcount() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void BroadcastResultMsg::set_has_sendcount() {
  _has_bits_[0] |= 0x00000040u;
}
inline void BroadcastResultMsg::clear_has_sendcount() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void BroadcastResultMsg::clear_sendcount() {
  sendcount_ = 0;
  clear_has_sendcount();
}
inline ::google::protobuf::int32 BroadcastResultMsg::sendcount() const {
  // @@protoc_insertion_point(field_get:kbd_idlfile.BroadcastResultMsg.sendCount)
  return sendcount_;
}
inline void BroadcastResultMsg::set_sendcount(::google::protobuf::int32 value) {
  set_has_sendcount();
  sendcount_ = value;
  // @@protoc_insertion_point(field_set:kbd_idlfile.BroadcastResultMsg.sendCount)
}

// required string pathFile = 8;
inline bool BroadcastResultMsg::has_pathfile() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void BroadcastResultMsg::set_has_pathfile() {
  _has_bits_[0] |= 0x00000080u;
}
inline void BroadcastResultMsg::clear_has_pathfile() {
  _has_bits_[0] &= ~0x00000080u;
}
inline void BroadcastResultMsg::clear_pathfile() {
  if (pathfile_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    pathfile_->clear();
  }
  clear_has_pathfile();
}
inline const ::std::string& BroadcastResultMsg::pathfile() const {
  // @@protoc_insertion_point(field_get:kbd_idlfile.BroadcastResultMsg.pathFile)
  return *pathfile_;
}
inline void BroadcastResultMsg::set_pathfile(const ::std::string& value) {
  set_has_pathfile();
  if (pathfile_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    pathfile_ = new ::std::string;
  }
  pathfile_->assign(value);
  // @@protoc_insertion_point(field_set:kbd_idlfile.BroadcastResultMsg.pathFile)
}
inline void BroadcastResultMsg::set_pathfile(const char* value) {
  set_has_pathfile();
  if (pathfile_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    pathfile_ = new ::std::string;
  }
  pathfile_->assign(value);
  // @@protoc_insertion_point(field_set_char:kbd_idlfile.BroadcastResultMsg.pathFile)
}
inline void BroadcastResultMsg::set_pathfile(const char* value, size_t size) {
  set_has_pathfile();
  if (pathfile_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    pathfile_ = new ::std::string;
  }
  pathfile_->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:kbd_idlfile.BroadcastResultMsg.pathFile)
}
inline ::std::string* BroadcastResultMsg::mutable_pathfile() {
  set_has_pathfile();
  if (pathfile_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    pathfile_ = new ::std::string;
  }
  // @@protoc_insertion_point(field_mutable:kbd_idlfile.BroadcastResultMsg.pathFile)
  return pathfile_;
}
inline ::std::string* BroadcastResultMsg::release_pathfile() {
  clear_has_pathfile();
  if (pathfile_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    return NULL;
  } else {
    ::std::string* temp = pathfile_;
    pathfile_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    return temp;
  }
}
inline void BroadcastResultMsg::set_allocated_pathfile(::std::string* pathfile) {
  if (pathfile_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete pathfile_;
  }
  if (pathfile) {
    set_has_pathfile();
    pathfile_ = pathfile;
  } else {
    clear_has_pathfile();
    pathfile_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  // @@protoc_insertion_point(field_set_allocated:kbd_idlfile.BroadcastResultMsg.pathFile)
}


// @@protoc_insertion_point(namespace_scope)

}  // namespace kbd_idlfile

#ifndef SWIG
namespace google {
namespace protobuf {

template <> struct is_proto_enum< ::kbd_idlfile::enTaskType> : ::google::protobuf::internal::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::kbd_idlfile::enTaskType>() {
  return ::kbd_idlfile::enTaskType_descriptor();
}
template <> struct is_proto_enum< ::kbd_idlfile::enTaskStatusType> : ::google::protobuf::internal::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::kbd_idlfile::enTaskStatusType>() {
  return ::kbd_idlfile::enTaskStatusType_descriptor();
}

}  // namespace google
}  // namespace protobuf
#endif  // SWIG

// @@protoc_insertion_point(global_scope)

#endif  // PROTOBUF_FileSynch_2eproto__INCLUDED