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

#ifndef GOOGLE_PROTOBUF_INCLUDED_commsg_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_commsg_2eproto

#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3017000
#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 3017003 < PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
#endif

#include <google/protobuf/port_undef.inc>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_table_driven.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/metadata_lite.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/unknown_field_set.h>
#include "protomsg.pb.h"
#include "alarm.pb.h"
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_commsg_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_commsg_2eproto {
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[5]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_commsg_2eproto;
namespace protomsg {
class RuleMessage;
struct RuleMessageDefaultTypeInternal;
extern RuleMessageDefaultTypeInternal _RuleMessage_default_instance_;
class SdkMessage;
struct SdkMessageDefaultTypeInternal;
extern SdkMessageDefaultTypeInternal _SdkMessage_default_instance_;
class SdkmsgWithTask;
struct SdkmsgWithTaskDefaultTypeInternal;
extern SdkmsgWithTaskDefaultTypeInternal _SdkmsgWithTask_default_instance_;
class TaskLabel;
struct TaskLabelDefaultTypeInternal;
extern TaskLabelDefaultTypeInternal _TaskLabel_default_instance_;
class recvmsg;
struct recvmsgDefaultTypeInternal;
extern recvmsgDefaultTypeInternal _recvmsg_default_instance_;
}  // namespace protomsg
PROTOBUF_NAMESPACE_OPEN
template<> ::protomsg::RuleMessage* Arena::CreateMaybeMessage<::protomsg::RuleMessage>(Arena*);
template<> ::protomsg::SdkMessage* Arena::CreateMaybeMessage<::protomsg::SdkMessage>(Arena*);
template<> ::protomsg::SdkmsgWithTask* Arena::CreateMaybeMessage<::protomsg::SdkmsgWithTask>(Arena*);
template<> ::protomsg::TaskLabel* Arena::CreateMaybeMessage<::protomsg::TaskLabel>(Arena*);
template<> ::protomsg::recvmsg* Arena::CreateMaybeMessage<::protomsg::recvmsg>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace protomsg {

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

class SdkmsgWithTask final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:protomsg.SdkmsgWithTask) */ {
 public:
  inline SdkmsgWithTask() : SdkmsgWithTask(nullptr) {}
  ~SdkmsgWithTask() override;
  explicit constexpr SdkmsgWithTask(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

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

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const SdkmsgWithTask& default_instance() {
    return *internal_default_instance();
  }
  static inline const SdkmsgWithTask* internal_default_instance() {
    return reinterpret_cast<const SdkmsgWithTask*>(
               &_SdkmsgWithTask_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

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

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

  inline SdkmsgWithTask* New() const final {
    return new SdkmsgWithTask();
  }

  SdkmsgWithTask* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<SdkmsgWithTask>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SdkmsgWithTask& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const SdkmsgWithTask& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SdkmsgWithTask* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "protomsg.SdkmsgWithTask";
  }
  protected:
  explicit SdkmsgWithTask(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kIpcidFieldNumber = 1,
    kSdktypeFieldNumber = 2,
    kSdkdataFieldNumber = 4,
  };
  // string ipcid = 1;
  void clear_ipcid();
  const std::string& ipcid() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_ipcid(ArgT0&& arg0, ArgT... args);
  std::string* mutable_ipcid();
  PROTOBUF_MUST_USE_RESULT std::string* release_ipcid();
  void set_allocated_ipcid(std::string* ipcid);
  private:
  const std::string& _internal_ipcid() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_ipcid(const std::string& value);
  std::string* _internal_mutable_ipcid();
  public:

  // string sdktype = 2;
  void clear_sdktype();
  const std::string& sdktype() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_sdktype(ArgT0&& arg0, ArgT... args);
  std::string* mutable_sdktype();
  PROTOBUF_MUST_USE_RESULT std::string* release_sdktype();
  void set_allocated_sdktype(std::string* sdktype);
  private:
  const std::string& _internal_sdktype() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_sdktype(const std::string& value);
  std::string* _internal_mutable_sdktype();
  public:

  // bytes sdkdata = 4;
  void clear_sdkdata();
  const std::string& sdkdata() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_sdkdata(ArgT0&& arg0, ArgT... args);
  std::string* mutable_sdkdata();
  PROTOBUF_MUST_USE_RESULT std::string* release_sdkdata();
  void set_allocated_sdkdata(std::string* sdkdata);
  private:
  const std::string& _internal_sdkdata() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_sdkdata(const std::string& value);
  std::string* _internal_mutable_sdkdata();
  public:

  // @@protoc_insertion_point(class_scope:protomsg.SdkmsgWithTask)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr ipcid_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr sdktype_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr sdkdata_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_commsg_2eproto;
};
// -------------------------------------------------------------------

class TaskLabel final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:protomsg.TaskLabel) */ {
 public:
  inline TaskLabel() : TaskLabel(nullptr) {}
  ~TaskLabel() override;
  explicit constexpr TaskLabel(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

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

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const TaskLabel& default_instance() {
    return *internal_default_instance();
  }
  static inline const TaskLabel* internal_default_instance() {
    return reinterpret_cast<const TaskLabel*>(
               &_TaskLabel_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

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

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

  inline TaskLabel* New() const final {
    return new TaskLabel();
  }

  TaskLabel* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<TaskLabel>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const TaskLabel& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const TaskLabel& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TaskLabel* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "protomsg.TaskLabel";
  }
  protected:
  explicit TaskLabel(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kSdkinfosFieldNumber = 3,
    kTaskidFieldNumber = 1,
    kTasknameFieldNumber = 2,
    kIndexFieldNumber = 4,
  };
  // repeated .protomsg.SdkmsgWithTask sdkinfos = 3;
  int sdkinfos_size() const;
  private:
  int _internal_sdkinfos_size() const;
  public:
  void clear_sdkinfos();
  ::protomsg::SdkmsgWithTask* mutable_sdkinfos(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::protomsg::SdkmsgWithTask >*
      mutable_sdkinfos();
  private:
  const ::protomsg::SdkmsgWithTask& _internal_sdkinfos(int index) const;
  ::protomsg::SdkmsgWithTask* _internal_add_sdkinfos();
  public:
  const ::protomsg::SdkmsgWithTask& sdkinfos(int index) const;
  ::protomsg::SdkmsgWithTask* add_sdkinfos();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::protomsg::SdkmsgWithTask >&
      sdkinfos() const;

  // string taskid = 1;
  void clear_taskid();
  const std::string& taskid() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_taskid(ArgT0&& arg0, ArgT... args);
  std::string* mutable_taskid();
  PROTOBUF_MUST_USE_RESULT std::string* release_taskid();
  void set_allocated_taskid(std::string* taskid);
  private:
  const std::string& _internal_taskid() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_taskid(const std::string& value);
  std::string* _internal_mutable_taskid();
  public:

  // string taskname = 2;
  void clear_taskname();
  const std::string& taskname() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_taskname(ArgT0&& arg0, ArgT... args);
  std::string* mutable_taskname();
  PROTOBUF_MUST_USE_RESULT std::string* release_taskname();
  void set_allocated_taskname(std::string* taskname);
  private:
  const std::string& _internal_taskname() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_taskname(const std::string& value);
  std::string* _internal_mutable_taskname();
  public:

  // int32 index = 4;
  void clear_index();
  ::PROTOBUF_NAMESPACE_ID::int32 index() const;
  void set_index(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_index() const;
  void _internal_set_index(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:protomsg.TaskLabel)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::protomsg::SdkmsgWithTask > sdkinfos_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr taskid_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr taskname_;
  ::PROTOBUF_NAMESPACE_ID::int32 index_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_commsg_2eproto;
};
// -------------------------------------------------------------------

class SdkMessage final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:protomsg.SdkMessage) */ {
 public:
  inline SdkMessage() : SdkMessage(nullptr) {}
  ~SdkMessage() override;
  explicit constexpr SdkMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

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

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const SdkMessage& default_instance() {
    return *internal_default_instance();
  }
  static inline const SdkMessage* internal_default_instance() {
    return reinterpret_cast<const SdkMessage*>(
               &_SdkMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

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

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

  inline SdkMessage* New() const final {
    return new SdkMessage();
  }

  SdkMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<SdkMessage>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SdkMessage& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const SdkMessage& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SdkMessage* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "protomsg.SdkMessage";
  }
  protected:
  explicit SdkMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kCidFieldNumber = 1,
    kCaddrFieldNumber = 2,
    kDataFieldNumber = 4,
    kTasklabFieldNumber = 3,
    kPushFieldNumber = 5,
  };
  // string cid = 1;
  void clear_cid();
  const std::string& cid() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_cid(ArgT0&& arg0, ArgT... args);
  std::string* mutable_cid();
  PROTOBUF_MUST_USE_RESULT std::string* release_cid();
  void set_allocated_cid(std::string* cid);
  private:
  const std::string& _internal_cid() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_cid(const std::string& value);
  std::string* _internal_mutable_cid();
  public:

  // string caddr = 2;
  void clear_caddr();
  const std::string& caddr() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_caddr(ArgT0&& arg0, ArgT... args);
  std::string* mutable_caddr();
  PROTOBUF_MUST_USE_RESULT std::string* release_caddr();
  void set_allocated_caddr(std::string* caddr);
  private:
  const std::string& _internal_caddr() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_caddr(const std::string& value);
  std::string* _internal_mutable_caddr();
  public:

  // bytes data = 4;
  void clear_data();
  const std::string& data() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_data(ArgT0&& arg0, ArgT... args);
  std::string* mutable_data();
  PROTOBUF_MUST_USE_RESULT std::string* release_data();
  void set_allocated_data(std::string* data);
  private:
  const std::string& _internal_data() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_data(const std::string& value);
  std::string* _internal_mutable_data();
  public:

  // .protomsg.TaskLabel tasklab = 3;
  bool has_tasklab() const;
  private:
  bool _internal_has_tasklab() const;
  public:
  void clear_tasklab();
  const ::protomsg::TaskLabel& tasklab() const;
  PROTOBUF_MUST_USE_RESULT ::protomsg::TaskLabel* release_tasklab();
  ::protomsg::TaskLabel* mutable_tasklab();
  void set_allocated_tasklab(::protomsg::TaskLabel* tasklab);
  private:
  const ::protomsg::TaskLabel& _internal_tasklab() const;
  ::protomsg::TaskLabel* _internal_mutable_tasklab();
  public:
  void unsafe_arena_set_allocated_tasklab(
      ::protomsg::TaskLabel* tasklab);
  ::protomsg::TaskLabel* unsafe_arena_release_tasklab();

  // .protomsg.PushAttach push = 5;
  bool has_push() const;
  private:
  bool _internal_has_push() const;
  public:
  void clear_push();
  const ::protomsg::PushAttach& push() const;
  PROTOBUF_MUST_USE_RESULT ::protomsg::PushAttach* release_push();
  ::protomsg::PushAttach* mutable_push();
  void set_allocated_push(::protomsg::PushAttach* push);
  private:
  const ::protomsg::PushAttach& _internal_push() const;
  ::protomsg::PushAttach* _internal_mutable_push();
  public:
  void unsafe_arena_set_allocated_push(
      ::protomsg::PushAttach* push);
  ::protomsg::PushAttach* unsafe_arena_release_push();

  // @@protoc_insertion_point(class_scope:protomsg.SdkMessage)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr cid_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr caddr_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr data_;
  ::protomsg::TaskLabel* tasklab_;
  ::protomsg::PushAttach* push_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_commsg_2eproto;
};
// -------------------------------------------------------------------

class recvmsg final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:protomsg.recvmsg) */ {
 public:
  inline recvmsg() : recvmsg(nullptr) {}
  ~recvmsg() override;
  explicit constexpr recvmsg(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

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

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const recvmsg& default_instance() {
    return *internal_default_instance();
  }
  static inline const recvmsg* internal_default_instance() {
    return reinterpret_cast<const recvmsg*>(
               &_recvmsg_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

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

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

  inline recvmsg* New() const final {
    return new recvmsg();
  }

  recvmsg* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<recvmsg>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const recvmsg& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const recvmsg& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(recvmsg* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "protomsg.recvmsg";
  }
  protected:
  explicit recvmsg(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kIdFieldNumber = 1,
    kAddrFieldNumber = 2,
    kPicdataFieldNumber = 3,
  };
  // string id = 1;
  void clear_id();
  const std::string& id() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_id(ArgT0&& arg0, ArgT... args);
  std::string* mutable_id();
  PROTOBUF_MUST_USE_RESULT std::string* release_id();
  void set_allocated_id(std::string* id);
  private:
  const std::string& _internal_id() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_id(const std::string& value);
  std::string* _internal_mutable_id();
  public:

  // string addr = 2;
  void clear_addr();
  const std::string& addr() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_addr(ArgT0&& arg0, ArgT... args);
  std::string* mutable_addr();
  PROTOBUF_MUST_USE_RESULT std::string* release_addr();
  void set_allocated_addr(std::string* addr);
  private:
  const std::string& _internal_addr() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_addr(const std::string& value);
  std::string* _internal_mutable_addr();
  public:

  // bytes picdata = 3;
  void clear_picdata();
  const std::string& picdata() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_picdata(ArgT0&& arg0, ArgT... args);
  std::string* mutable_picdata();
  PROTOBUF_MUST_USE_RESULT std::string* release_picdata();
  void set_allocated_picdata(std::string* picdata);
  private:
  const std::string& _internal_picdata() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_picdata(const std::string& value);
  std::string* _internal_mutable_picdata();
  public:

  // @@protoc_insertion_point(class_scope:protomsg.recvmsg)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr id_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr addr_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr picdata_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_commsg_2eproto;
};
// -------------------------------------------------------------------

class RuleMessage final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:protomsg.RuleMessage) */ {
 public:
  inline RuleMessage() : RuleMessage(nullptr) {}
  ~RuleMessage() override;
  explicit constexpr RuleMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

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

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const RuleMessage& default_instance() {
    return *internal_default_instance();
  }
  static inline const RuleMessage* internal_default_instance() {
    return reinterpret_cast<const RuleMessage*>(
               &_RuleMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;

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

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

  inline RuleMessage* New() const final {
    return new RuleMessage();
  }

  RuleMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<RuleMessage>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const RuleMessage& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const RuleMessage& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RuleMessage* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "protomsg.RuleMessage";
  }
  protected:
  explicit RuleMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kTaskidFieldNumber = 1,
    kTasknameFieldNumber = 2,
    kMsgtypeFieldNumber = 3,
    kSdkmsgFieldNumber = 4,
    kAlarmmsgFieldNumber = 5,
  };
  // string taskid = 1;
  void clear_taskid();
  const std::string& taskid() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_taskid(ArgT0&& arg0, ArgT... args);
  std::string* mutable_taskid();
  PROTOBUF_MUST_USE_RESULT std::string* release_taskid();
  void set_allocated_taskid(std::string* taskid);
  private:
  const std::string& _internal_taskid() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_taskid(const std::string& value);
  std::string* _internal_mutable_taskid();
  public:

  // string taskname = 2;
  void clear_taskname();
  const std::string& taskname() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_taskname(ArgT0&& arg0, ArgT... args);
  std::string* mutable_taskname();
  PROTOBUF_MUST_USE_RESULT std::string* release_taskname();
  void set_allocated_taskname(std::string* taskname);
  private:
  const std::string& _internal_taskname() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_taskname(const std::string& value);
  std::string* _internal_mutable_taskname();
  public:

  // string msgtype = 3;
  void clear_msgtype();
  const std::string& msgtype() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_msgtype(ArgT0&& arg0, ArgT... args);
  std::string* mutable_msgtype();
  PROTOBUF_MUST_USE_RESULT std::string* release_msgtype();
  void set_allocated_msgtype(std::string* msgtype);
  private:
  const std::string& _internal_msgtype() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_msgtype(const std::string& value);
  std::string* _internal_mutable_msgtype();
  public:

  // .protomsg.SdkMessage sdkmsg = 4;
  bool has_sdkmsg() const;
  private:
  bool _internal_has_sdkmsg() const;
  public:
  void clear_sdkmsg();
  const ::protomsg::SdkMessage& sdkmsg() const;
  PROTOBUF_MUST_USE_RESULT ::protomsg::SdkMessage* release_sdkmsg();
  ::protomsg::SdkMessage* mutable_sdkmsg();
  void set_allocated_sdkmsg(::protomsg::SdkMessage* sdkmsg);
  private:
  const ::protomsg::SdkMessage& _internal_sdkmsg() const;
  ::protomsg::SdkMessage* _internal_mutable_sdkmsg();
  public:
  void unsafe_arena_set_allocated_sdkmsg(
      ::protomsg::SdkMessage* sdkmsg);
  ::protomsg::SdkMessage* unsafe_arena_release_sdkmsg();

  // .protomsg.AlarmMessage alarmmsg = 5;
  bool has_alarmmsg() const;
  private:
  bool _internal_has_alarmmsg() const;
  public:
  void clear_alarmmsg();
  const ::protomsg::AlarmMessage& alarmmsg() const;
  PROTOBUF_MUST_USE_RESULT ::protomsg::AlarmMessage* release_alarmmsg();
  ::protomsg::AlarmMessage* mutable_alarmmsg();
  void set_allocated_alarmmsg(::protomsg::AlarmMessage* alarmmsg);
  private:
  const ::protomsg::AlarmMessage& _internal_alarmmsg() const;
  ::protomsg::AlarmMessage* _internal_mutable_alarmmsg();
  public:
  void unsafe_arena_set_allocated_alarmmsg(
      ::protomsg::AlarmMessage* alarmmsg);
  ::protomsg::AlarmMessage* unsafe_arena_release_alarmmsg();

  // @@protoc_insertion_point(class_scope:protomsg.RuleMessage)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr taskid_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr taskname_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr msgtype_;
  ::protomsg::SdkMessage* sdkmsg_;
  ::protomsg::AlarmMessage* alarmmsg_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_commsg_2eproto;
};
// ===================================================================


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

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

// string ipcid = 1;
inline void SdkmsgWithTask::clear_ipcid() {
  ipcid_.ClearToEmpty();
}
inline const std::string& SdkmsgWithTask::ipcid() const {
  // @@protoc_insertion_point(field_get:protomsg.SdkmsgWithTask.ipcid)
  return _internal_ipcid();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SdkmsgWithTask::set_ipcid(ArgT0&& arg0, ArgT... args) {
 
 ipcid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:protomsg.SdkmsgWithTask.ipcid)
}
inline std::string* SdkmsgWithTask::mutable_ipcid() {
  std::string* _s = _internal_mutable_ipcid();
  // @@protoc_insertion_point(field_mutable:protomsg.SdkmsgWithTask.ipcid)
  return _s;
}
inline const std::string& SdkmsgWithTask::_internal_ipcid() const {
  return ipcid_.Get();
}
inline void SdkmsgWithTask::_internal_set_ipcid(const std::string& value) {
  
  ipcid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* SdkmsgWithTask::_internal_mutable_ipcid() {
  
  return ipcid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* SdkmsgWithTask::release_ipcid() {
  // @@protoc_insertion_point(field_release:protomsg.SdkmsgWithTask.ipcid)
  return ipcid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void SdkmsgWithTask::set_allocated_ipcid(std::string* ipcid) {
  if (ipcid != nullptr) {
    
  } else {
    
  }
  ipcid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ipcid,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:protomsg.SdkmsgWithTask.ipcid)
}

// string sdktype = 2;
inline void SdkmsgWithTask::clear_sdktype() {
  sdktype_.ClearToEmpty();
}
inline const std::string& SdkmsgWithTask::sdktype() const {
  // @@protoc_insertion_point(field_get:protomsg.SdkmsgWithTask.sdktype)
  return _internal_sdktype();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SdkmsgWithTask::set_sdktype(ArgT0&& arg0, ArgT... args) {
 
 sdktype_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:protomsg.SdkmsgWithTask.sdktype)
}
inline std::string* SdkmsgWithTask::mutable_sdktype() {
  std::string* _s = _internal_mutable_sdktype();
  // @@protoc_insertion_point(field_mutable:protomsg.SdkmsgWithTask.sdktype)
  return _s;
}
inline const std::string& SdkmsgWithTask::_internal_sdktype() const {
  return sdktype_.Get();
}
inline void SdkmsgWithTask::_internal_set_sdktype(const std::string& value) {
  
  sdktype_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* SdkmsgWithTask::_internal_mutable_sdktype() {
  
  return sdktype_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* SdkmsgWithTask::release_sdktype() {
  // @@protoc_insertion_point(field_release:protomsg.SdkmsgWithTask.sdktype)
  return sdktype_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void SdkmsgWithTask::set_allocated_sdktype(std::string* sdktype) {
  if (sdktype != nullptr) {
    
  } else {
    
  }
  sdktype_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), sdktype,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:protomsg.SdkmsgWithTask.sdktype)
}

// bytes sdkdata = 4;
inline void SdkmsgWithTask::clear_sdkdata() {
  sdkdata_.ClearToEmpty();
}
inline const std::string& SdkmsgWithTask::sdkdata() const {
  // @@protoc_insertion_point(field_get:protomsg.SdkmsgWithTask.sdkdata)
  return _internal_sdkdata();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SdkmsgWithTask::set_sdkdata(ArgT0&& arg0, ArgT... args) {
 
 sdkdata_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:protomsg.SdkmsgWithTask.sdkdata)
}
inline std::string* SdkmsgWithTask::mutable_sdkdata() {
  std::string* _s = _internal_mutable_sdkdata();
  // @@protoc_insertion_point(field_mutable:protomsg.SdkmsgWithTask.sdkdata)
  return _s;
}
inline const std::string& SdkmsgWithTask::_internal_sdkdata() const {
  return sdkdata_.Get();
}
inline void SdkmsgWithTask::_internal_set_sdkdata(const std::string& value) {
  
  sdkdata_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* SdkmsgWithTask::_internal_mutable_sdkdata() {
  
  return sdkdata_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* SdkmsgWithTask::release_sdkdata() {
  // @@protoc_insertion_point(field_release:protomsg.SdkmsgWithTask.sdkdata)
  return sdkdata_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void SdkmsgWithTask::set_allocated_sdkdata(std::string* sdkdata) {
  if (sdkdata != nullptr) {
    
  } else {
    
  }
  sdkdata_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), sdkdata,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:protomsg.SdkmsgWithTask.sdkdata)
}

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

// TaskLabel

// string taskid = 1;
inline void TaskLabel::clear_taskid() {
  taskid_.ClearToEmpty();
}
inline const std::string& TaskLabel::taskid() const {
  // @@protoc_insertion_point(field_get:protomsg.TaskLabel.taskid)
  return _internal_taskid();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void TaskLabel::set_taskid(ArgT0&& arg0, ArgT... args) {
 
 taskid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:protomsg.TaskLabel.taskid)
}
inline std::string* TaskLabel::mutable_taskid() {
  std::string* _s = _internal_mutable_taskid();
  // @@protoc_insertion_point(field_mutable:protomsg.TaskLabel.taskid)
  return _s;
}
inline const std::string& TaskLabel::_internal_taskid() const {
  return taskid_.Get();
}
inline void TaskLabel::_internal_set_taskid(const std::string& value) {
  
  taskid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* TaskLabel::_internal_mutable_taskid() {
  
  return taskid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* TaskLabel::release_taskid() {
  // @@protoc_insertion_point(field_release:protomsg.TaskLabel.taskid)
  return taskid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void TaskLabel::set_allocated_taskid(std::string* taskid) {
  if (taskid != nullptr) {
    
  } else {
    
  }
  taskid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), taskid,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:protomsg.TaskLabel.taskid)
}

// string taskname = 2;
inline void TaskLabel::clear_taskname() {
  taskname_.ClearToEmpty();
}
inline const std::string& TaskLabel::taskname() const {
  // @@protoc_insertion_point(field_get:protomsg.TaskLabel.taskname)
  return _internal_taskname();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void TaskLabel::set_taskname(ArgT0&& arg0, ArgT... args) {
 
 taskname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:protomsg.TaskLabel.taskname)
}
inline std::string* TaskLabel::mutable_taskname() {
  std::string* _s = _internal_mutable_taskname();
  // @@protoc_insertion_point(field_mutable:protomsg.TaskLabel.taskname)
  return _s;
}
inline const std::string& TaskLabel::_internal_taskname() const {
  return taskname_.Get();
}
inline void TaskLabel::_internal_set_taskname(const std::string& value) {
  
  taskname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* TaskLabel::_internal_mutable_taskname() {
  
  return taskname_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* TaskLabel::release_taskname() {
  // @@protoc_insertion_point(field_release:protomsg.TaskLabel.taskname)
  return taskname_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void TaskLabel::set_allocated_taskname(std::string* taskname) {
  if (taskname != nullptr) {
    
  } else {
    
  }
  taskname_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), taskname,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:protomsg.TaskLabel.taskname)
}

// repeated .protomsg.SdkmsgWithTask sdkinfos = 3;
inline int TaskLabel::_internal_sdkinfos_size() const {
  return sdkinfos_.size();
}
inline int TaskLabel::sdkinfos_size() const {
  return _internal_sdkinfos_size();
}
inline void TaskLabel::clear_sdkinfos() {
  sdkinfos_.Clear();
}
inline ::protomsg::SdkmsgWithTask* TaskLabel::mutable_sdkinfos(int index) {
  // @@protoc_insertion_point(field_mutable:protomsg.TaskLabel.sdkinfos)
  return sdkinfos_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::protomsg::SdkmsgWithTask >*
TaskLabel::mutable_sdkinfos() {
  // @@protoc_insertion_point(field_mutable_list:protomsg.TaskLabel.sdkinfos)
  return &sdkinfos_;
}
inline const ::protomsg::SdkmsgWithTask& TaskLabel::_internal_sdkinfos(int index) const {
  return sdkinfos_.Get(index);
}
inline const ::protomsg::SdkmsgWithTask& TaskLabel::sdkinfos(int index) const {
  // @@protoc_insertion_point(field_get:protomsg.TaskLabel.sdkinfos)
  return _internal_sdkinfos(index);
}
inline ::protomsg::SdkmsgWithTask* TaskLabel::_internal_add_sdkinfos() {
  return sdkinfos_.Add();
}
inline ::protomsg::SdkmsgWithTask* TaskLabel::add_sdkinfos() {
  ::protomsg::SdkmsgWithTask* _add = _internal_add_sdkinfos();
  // @@protoc_insertion_point(field_add:protomsg.TaskLabel.sdkinfos)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::protomsg::SdkmsgWithTask >&
TaskLabel::sdkinfos() const {
  // @@protoc_insertion_point(field_list:protomsg.TaskLabel.sdkinfos)
  return sdkinfos_;
}

// int32 index = 4;
inline void TaskLabel::clear_index() {
  index_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 TaskLabel::_internal_index() const {
  return index_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 TaskLabel::index() const {
  // @@protoc_insertion_point(field_get:protomsg.TaskLabel.index)
  return _internal_index();
}
inline void TaskLabel::_internal_set_index(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  index_ = value;
}
inline void TaskLabel::set_index(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_index(value);
  // @@protoc_insertion_point(field_set:protomsg.TaskLabel.index)
}

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

// SdkMessage

// string cid = 1;
inline void SdkMessage::clear_cid() {
  cid_.ClearToEmpty();
}
inline const std::string& SdkMessage::cid() const {
  // @@protoc_insertion_point(field_get:protomsg.SdkMessage.cid)
  return _internal_cid();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SdkMessage::set_cid(ArgT0&& arg0, ArgT... args) {
 
 cid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:protomsg.SdkMessage.cid)
}
inline std::string* SdkMessage::mutable_cid() {
  std::string* _s = _internal_mutable_cid();
  // @@protoc_insertion_point(field_mutable:protomsg.SdkMessage.cid)
  return _s;
}
inline const std::string& SdkMessage::_internal_cid() const {
  return cid_.Get();
}
inline void SdkMessage::_internal_set_cid(const std::string& value) {
  
  cid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* SdkMessage::_internal_mutable_cid() {
  
  return cid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* SdkMessage::release_cid() {
  // @@protoc_insertion_point(field_release:protomsg.SdkMessage.cid)
  return cid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void SdkMessage::set_allocated_cid(std::string* cid) {
  if (cid != nullptr) {
    
  } else {
    
  }
  cid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), cid,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:protomsg.SdkMessage.cid)
}

// string caddr = 2;
inline void SdkMessage::clear_caddr() {
  caddr_.ClearToEmpty();
}
inline const std::string& SdkMessage::caddr() const {
  // @@protoc_insertion_point(field_get:protomsg.SdkMessage.caddr)
  return _internal_caddr();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SdkMessage::set_caddr(ArgT0&& arg0, ArgT... args) {
 
 caddr_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:protomsg.SdkMessage.caddr)
}
inline std::string* SdkMessage::mutable_caddr() {
  std::string* _s = _internal_mutable_caddr();
  // @@protoc_insertion_point(field_mutable:protomsg.SdkMessage.caddr)
  return _s;
}
inline const std::string& SdkMessage::_internal_caddr() const {
  return caddr_.Get();
}
inline void SdkMessage::_internal_set_caddr(const std::string& value) {
  
  caddr_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* SdkMessage::_internal_mutable_caddr() {
  
  return caddr_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* SdkMessage::release_caddr() {
  // @@protoc_insertion_point(field_release:protomsg.SdkMessage.caddr)
  return caddr_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void SdkMessage::set_allocated_caddr(std::string* caddr) {
  if (caddr != nullptr) {
    
  } else {
    
  }
  caddr_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), caddr,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:protomsg.SdkMessage.caddr)
}

// .protomsg.TaskLabel tasklab = 3;
inline bool SdkMessage::_internal_has_tasklab() const {
  return this != internal_default_instance() && tasklab_ != nullptr;
}
inline bool SdkMessage::has_tasklab() const {
  return _internal_has_tasklab();
}
inline void SdkMessage::clear_tasklab() {
  if (GetArenaForAllocation() == nullptr && tasklab_ != nullptr) {
    delete tasklab_;
  }
  tasklab_ = nullptr;
}
inline const ::protomsg::TaskLabel& SdkMessage::_internal_tasklab() const {
  const ::protomsg::TaskLabel* p = tasklab_;
  return p != nullptr ? *p : reinterpret_cast<const ::protomsg::TaskLabel&>(
      ::protomsg::_TaskLabel_default_instance_);
}
inline const ::protomsg::TaskLabel& SdkMessage::tasklab() const {
  // @@protoc_insertion_point(field_get:protomsg.SdkMessage.tasklab)
  return _internal_tasklab();
}
inline void SdkMessage::unsafe_arena_set_allocated_tasklab(
    ::protomsg::TaskLabel* tasklab) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(tasklab_);
  }
  tasklab_ = tasklab;
  if (tasklab) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protomsg.SdkMessage.tasklab)
}
inline ::protomsg::TaskLabel* SdkMessage::release_tasklab() {
  
  ::protomsg::TaskLabel* temp = tasklab_;
  tasklab_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::protomsg::TaskLabel* SdkMessage::unsafe_arena_release_tasklab() {
  // @@protoc_insertion_point(field_release:protomsg.SdkMessage.tasklab)
  
  ::protomsg::TaskLabel* temp = tasklab_;
  tasklab_ = nullptr;
  return temp;
}
inline ::protomsg::TaskLabel* SdkMessage::_internal_mutable_tasklab() {
  
  if (tasklab_ == nullptr) {
    auto* p = CreateMaybeMessage<::protomsg::TaskLabel>(GetArenaForAllocation());
    tasklab_ = p;
  }
  return tasklab_;
}
inline ::protomsg::TaskLabel* SdkMessage::mutable_tasklab() {
  ::protomsg::TaskLabel* _msg = _internal_mutable_tasklab();
  // @@protoc_insertion_point(field_mutable:protomsg.SdkMessage.tasklab)
  return _msg;
}
inline void SdkMessage::set_allocated_tasklab(::protomsg::TaskLabel* tasklab) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete tasklab_;
  }
  if (tasklab) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::protomsg::TaskLabel>::GetOwningArena(tasklab);
    if (message_arena != submessage_arena) {
      tasklab = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, tasklab, submessage_arena);
    }
    
  } else {
    
  }
  tasklab_ = tasklab;
  // @@protoc_insertion_point(field_set_allocated:protomsg.SdkMessage.tasklab)
}

// bytes data = 4;
inline void SdkMessage::clear_data() {
  data_.ClearToEmpty();
}
inline const std::string& SdkMessage::data() const {
  // @@protoc_insertion_point(field_get:protomsg.SdkMessage.data)
  return _internal_data();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SdkMessage::set_data(ArgT0&& arg0, ArgT... args) {
 
 data_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:protomsg.SdkMessage.data)
}
inline std::string* SdkMessage::mutable_data() {
  std::string* _s = _internal_mutable_data();
  // @@protoc_insertion_point(field_mutable:protomsg.SdkMessage.data)
  return _s;
}
inline const std::string& SdkMessage::_internal_data() const {
  return data_.Get();
}
inline void SdkMessage::_internal_set_data(const std::string& value) {
  
  data_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* SdkMessage::_internal_mutable_data() {
  
  return data_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* SdkMessage::release_data() {
  // @@protoc_insertion_point(field_release:protomsg.SdkMessage.data)
  return data_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void SdkMessage::set_allocated_data(std::string* data) {
  if (data != nullptr) {
    
  } else {
    
  }
  data_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), data,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:protomsg.SdkMessage.data)
}

// .protomsg.PushAttach push = 5;
inline bool SdkMessage::_internal_has_push() const {
  return this != internal_default_instance() && push_ != nullptr;
}
inline bool SdkMessage::has_push() const {
  return _internal_has_push();
}
inline const ::protomsg::PushAttach& SdkMessage::_internal_push() const {
  const ::protomsg::PushAttach* p = push_;
  return p != nullptr ? *p : reinterpret_cast<const ::protomsg::PushAttach&>(
      ::protomsg::_PushAttach_default_instance_);
}
inline const ::protomsg::PushAttach& SdkMessage::push() const {
  // @@protoc_insertion_point(field_get:protomsg.SdkMessage.push)
  return _internal_push();
}
inline void SdkMessage::unsafe_arena_set_allocated_push(
    ::protomsg::PushAttach* push) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(push_);
  }
  push_ = push;
  if (push) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protomsg.SdkMessage.push)
}
inline ::protomsg::PushAttach* SdkMessage::release_push() {
  
  ::protomsg::PushAttach* temp = push_;
  push_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::protomsg::PushAttach* SdkMessage::unsafe_arena_release_push() {
  // @@protoc_insertion_point(field_release:protomsg.SdkMessage.push)
  
  ::protomsg::PushAttach* temp = push_;
  push_ = nullptr;
  return temp;
}
inline ::protomsg::PushAttach* SdkMessage::_internal_mutable_push() {
  
  if (push_ == nullptr) {
    auto* p = CreateMaybeMessage<::protomsg::PushAttach>(GetArenaForAllocation());
    push_ = p;
  }
  return push_;
}
inline ::protomsg::PushAttach* SdkMessage::mutable_push() {
  ::protomsg::PushAttach* _msg = _internal_mutable_push();
  // @@protoc_insertion_point(field_mutable:protomsg.SdkMessage.push)
  return _msg;
}
inline void SdkMessage::set_allocated_push(::protomsg::PushAttach* push) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(push_);
  }
  if (push) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(push));
    if (message_arena != submessage_arena) {
      push = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, push, submessage_arena);
    }
    
  } else {
    
  }
  push_ = push;
  // @@protoc_insertion_point(field_set_allocated:protomsg.SdkMessage.push)
}

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

// recvmsg

// string id = 1;
inline void recvmsg::clear_id() {
  id_.ClearToEmpty();
}
inline const std::string& recvmsg::id() const {
  // @@protoc_insertion_point(field_get:protomsg.recvmsg.id)
  return _internal_id();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void recvmsg::set_id(ArgT0&& arg0, ArgT... args) {
 
 id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:protomsg.recvmsg.id)
}
inline std::string* recvmsg::mutable_id() {
  std::string* _s = _internal_mutable_id();
  // @@protoc_insertion_point(field_mutable:protomsg.recvmsg.id)
  return _s;
}
inline const std::string& recvmsg::_internal_id() const {
  return id_.Get();
}
inline void recvmsg::_internal_set_id(const std::string& value) {
  
  id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* recvmsg::_internal_mutable_id() {
  
  return id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* recvmsg::release_id() {
  // @@protoc_insertion_point(field_release:protomsg.recvmsg.id)
  return id_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void recvmsg::set_allocated_id(std::string* id) {
  if (id != nullptr) {
    
  } else {
    
  }
  id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), id,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:protomsg.recvmsg.id)
}

// string addr = 2;
inline void recvmsg::clear_addr() {
  addr_.ClearToEmpty();
}
inline const std::string& recvmsg::addr() const {
  // @@protoc_insertion_point(field_get:protomsg.recvmsg.addr)
  return _internal_addr();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void recvmsg::set_addr(ArgT0&& arg0, ArgT... args) {
 
 addr_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:protomsg.recvmsg.addr)
}
inline std::string* recvmsg::mutable_addr() {
  std::string* _s = _internal_mutable_addr();
  // @@protoc_insertion_point(field_mutable:protomsg.recvmsg.addr)
  return _s;
}
inline const std::string& recvmsg::_internal_addr() const {
  return addr_.Get();
}
inline void recvmsg::_internal_set_addr(const std::string& value) {
  
  addr_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* recvmsg::_internal_mutable_addr() {
  
  return addr_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* recvmsg::release_addr() {
  // @@protoc_insertion_point(field_release:protomsg.recvmsg.addr)
  return addr_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void recvmsg::set_allocated_addr(std::string* addr) {
  if (addr != nullptr) {
    
  } else {
    
  }
  addr_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), addr,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:protomsg.recvmsg.addr)
}

// bytes picdata = 3;
inline void recvmsg::clear_picdata() {
  picdata_.ClearToEmpty();
}
inline const std::string& recvmsg::picdata() const {
  // @@protoc_insertion_point(field_get:protomsg.recvmsg.picdata)
  return _internal_picdata();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void recvmsg::set_picdata(ArgT0&& arg0, ArgT... args) {
 
 picdata_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:protomsg.recvmsg.picdata)
}
inline std::string* recvmsg::mutable_picdata() {
  std::string* _s = _internal_mutable_picdata();
  // @@protoc_insertion_point(field_mutable:protomsg.recvmsg.picdata)
  return _s;
}
inline const std::string& recvmsg::_internal_picdata() const {
  return picdata_.Get();
}
inline void recvmsg::_internal_set_picdata(const std::string& value) {
  
  picdata_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* recvmsg::_internal_mutable_picdata() {
  
  return picdata_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* recvmsg::release_picdata() {
  // @@protoc_insertion_point(field_release:protomsg.recvmsg.picdata)
  return picdata_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void recvmsg::set_allocated_picdata(std::string* picdata) {
  if (picdata != nullptr) {
    
  } else {
    
  }
  picdata_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), picdata,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:protomsg.recvmsg.picdata)
}

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

// RuleMessage

// string taskid = 1;
inline void RuleMessage::clear_taskid() {
  taskid_.ClearToEmpty();
}
inline const std::string& RuleMessage::taskid() const {
  // @@protoc_insertion_point(field_get:protomsg.RuleMessage.taskid)
  return _internal_taskid();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RuleMessage::set_taskid(ArgT0&& arg0, ArgT... args) {
 
 taskid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:protomsg.RuleMessage.taskid)
}
inline std::string* RuleMessage::mutable_taskid() {
  std::string* _s = _internal_mutable_taskid();
  // @@protoc_insertion_point(field_mutable:protomsg.RuleMessage.taskid)
  return _s;
}
inline const std::string& RuleMessage::_internal_taskid() const {
  return taskid_.Get();
}
inline void RuleMessage::_internal_set_taskid(const std::string& value) {
  
  taskid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* RuleMessage::_internal_mutable_taskid() {
  
  return taskid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* RuleMessage::release_taskid() {
  // @@protoc_insertion_point(field_release:protomsg.RuleMessage.taskid)
  return taskid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void RuleMessage::set_allocated_taskid(std::string* taskid) {
  if (taskid != nullptr) {
    
  } else {
    
  }
  taskid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), taskid,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:protomsg.RuleMessage.taskid)
}

// string taskname = 2;
inline void RuleMessage::clear_taskname() {
  taskname_.ClearToEmpty();
}
inline const std::string& RuleMessage::taskname() const {
  // @@protoc_insertion_point(field_get:protomsg.RuleMessage.taskname)
  return _internal_taskname();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RuleMessage::set_taskname(ArgT0&& arg0, ArgT... args) {
 
 taskname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:protomsg.RuleMessage.taskname)
}
inline std::string* RuleMessage::mutable_taskname() {
  std::string* _s = _internal_mutable_taskname();
  // @@protoc_insertion_point(field_mutable:protomsg.RuleMessage.taskname)
  return _s;
}
inline const std::string& RuleMessage::_internal_taskname() const {
  return taskname_.Get();
}
inline void RuleMessage::_internal_set_taskname(const std::string& value) {
  
  taskname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* RuleMessage::_internal_mutable_taskname() {
  
  return taskname_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* RuleMessage::release_taskname() {
  // @@protoc_insertion_point(field_release:protomsg.RuleMessage.taskname)
  return taskname_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void RuleMessage::set_allocated_taskname(std::string* taskname) {
  if (taskname != nullptr) {
    
  } else {
    
  }
  taskname_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), taskname,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:protomsg.RuleMessage.taskname)
}

// string msgtype = 3;
inline void RuleMessage::clear_msgtype() {
  msgtype_.ClearToEmpty();
}
inline const std::string& RuleMessage::msgtype() const {
  // @@protoc_insertion_point(field_get:protomsg.RuleMessage.msgtype)
  return _internal_msgtype();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RuleMessage::set_msgtype(ArgT0&& arg0, ArgT... args) {
 
 msgtype_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:protomsg.RuleMessage.msgtype)
}
inline std::string* RuleMessage::mutable_msgtype() {
  std::string* _s = _internal_mutable_msgtype();
  // @@protoc_insertion_point(field_mutable:protomsg.RuleMessage.msgtype)
  return _s;
}
inline const std::string& RuleMessage::_internal_msgtype() const {
  return msgtype_.Get();
}
inline void RuleMessage::_internal_set_msgtype(const std::string& value) {
  
  msgtype_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* RuleMessage::_internal_mutable_msgtype() {
  
  return msgtype_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* RuleMessage::release_msgtype() {
  // @@protoc_insertion_point(field_release:protomsg.RuleMessage.msgtype)
  return msgtype_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void RuleMessage::set_allocated_msgtype(std::string* msgtype) {
  if (msgtype != nullptr) {
    
  } else {
    
  }
  msgtype_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), msgtype,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:protomsg.RuleMessage.msgtype)
}

// .protomsg.SdkMessage sdkmsg = 4;
inline bool RuleMessage::_internal_has_sdkmsg() const {
  return this != internal_default_instance() && sdkmsg_ != nullptr;
}
inline bool RuleMessage::has_sdkmsg() const {
  return _internal_has_sdkmsg();
}
inline void RuleMessage::clear_sdkmsg() {
  if (GetArenaForAllocation() == nullptr && sdkmsg_ != nullptr) {
    delete sdkmsg_;
  }
  sdkmsg_ = nullptr;
}
inline const ::protomsg::SdkMessage& RuleMessage::_internal_sdkmsg() const {
  const ::protomsg::SdkMessage* p = sdkmsg_;
  return p != nullptr ? *p : reinterpret_cast<const ::protomsg::SdkMessage&>(
      ::protomsg::_SdkMessage_default_instance_);
}
inline const ::protomsg::SdkMessage& RuleMessage::sdkmsg() const {
  // @@protoc_insertion_point(field_get:protomsg.RuleMessage.sdkmsg)
  return _internal_sdkmsg();
}
inline void RuleMessage::unsafe_arena_set_allocated_sdkmsg(
    ::protomsg::SdkMessage* sdkmsg) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(sdkmsg_);
  }
  sdkmsg_ = sdkmsg;
  if (sdkmsg) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protomsg.RuleMessage.sdkmsg)
}
inline ::protomsg::SdkMessage* RuleMessage::release_sdkmsg() {
  
  ::protomsg::SdkMessage* temp = sdkmsg_;
  sdkmsg_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::protomsg::SdkMessage* RuleMessage::unsafe_arena_release_sdkmsg() {
  // @@protoc_insertion_point(field_release:protomsg.RuleMessage.sdkmsg)
  
  ::protomsg::SdkMessage* temp = sdkmsg_;
  sdkmsg_ = nullptr;
  return temp;
}
inline ::protomsg::SdkMessage* RuleMessage::_internal_mutable_sdkmsg() {
  
  if (sdkmsg_ == nullptr) {
    auto* p = CreateMaybeMessage<::protomsg::SdkMessage>(GetArenaForAllocation());
    sdkmsg_ = p;
  }
  return sdkmsg_;
}
inline ::protomsg::SdkMessage* RuleMessage::mutable_sdkmsg() {
  ::protomsg::SdkMessage* _msg = _internal_mutable_sdkmsg();
  // @@protoc_insertion_point(field_mutable:protomsg.RuleMessage.sdkmsg)
  return _msg;
}
inline void RuleMessage::set_allocated_sdkmsg(::protomsg::SdkMessage* sdkmsg) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete sdkmsg_;
  }
  if (sdkmsg) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::protomsg::SdkMessage>::GetOwningArena(sdkmsg);
    if (message_arena != submessage_arena) {
      sdkmsg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, sdkmsg, submessage_arena);
    }
    
  } else {
    
  }
  sdkmsg_ = sdkmsg;
  // @@protoc_insertion_point(field_set_allocated:protomsg.RuleMessage.sdkmsg)
}

// .protomsg.AlarmMessage alarmmsg = 5;
inline bool RuleMessage::_internal_has_alarmmsg() const {
  return this != internal_default_instance() && alarmmsg_ != nullptr;
}
inline bool RuleMessage::has_alarmmsg() const {
  return _internal_has_alarmmsg();
}
inline const ::protomsg::AlarmMessage& RuleMessage::_internal_alarmmsg() const {
  const ::protomsg::AlarmMessage* p = alarmmsg_;
  return p != nullptr ? *p : reinterpret_cast<const ::protomsg::AlarmMessage&>(
      ::protomsg::_AlarmMessage_default_instance_);
}
inline const ::protomsg::AlarmMessage& RuleMessage::alarmmsg() const {
  // @@protoc_insertion_point(field_get:protomsg.RuleMessage.alarmmsg)
  return _internal_alarmmsg();
}
inline void RuleMessage::unsafe_arena_set_allocated_alarmmsg(
    ::protomsg::AlarmMessage* alarmmsg) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(alarmmsg_);
  }
  alarmmsg_ = alarmmsg;
  if (alarmmsg) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protomsg.RuleMessage.alarmmsg)
}
inline ::protomsg::AlarmMessage* RuleMessage::release_alarmmsg() {
  
  ::protomsg::AlarmMessage* temp = alarmmsg_;
  alarmmsg_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::protomsg::AlarmMessage* RuleMessage::unsafe_arena_release_alarmmsg() {
  // @@protoc_insertion_point(field_release:protomsg.RuleMessage.alarmmsg)
  
  ::protomsg::AlarmMessage* temp = alarmmsg_;
  alarmmsg_ = nullptr;
  return temp;
}
inline ::protomsg::AlarmMessage* RuleMessage::_internal_mutable_alarmmsg() {
  
  if (alarmmsg_ == nullptr) {
    auto* p = CreateMaybeMessage<::protomsg::AlarmMessage>(GetArenaForAllocation());
    alarmmsg_ = p;
  }
  return alarmmsg_;
}
inline ::protomsg::AlarmMessage* RuleMessage::mutable_alarmmsg() {
  ::protomsg::AlarmMessage* _msg = _internal_mutable_alarmmsg();
  // @@protoc_insertion_point(field_mutable:protomsg.RuleMessage.alarmmsg)
  return _msg;
}
inline void RuleMessage::set_allocated_alarmmsg(::protomsg::AlarmMessage* alarmmsg) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(alarmmsg_);
  }
  if (alarmmsg) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(alarmmsg));
    if (message_arena != submessage_arena) {
      alarmmsg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, alarmmsg, submessage_arena);
    }
    
  } else {
    
  }
  alarmmsg_ = alarmmsg;
  // @@protoc_insertion_point(field_set_allocated:protomsg.RuleMessage.alarmmsg)
}

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

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

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

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace protomsg

// @@protoc_insertion_point(global_scope)

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