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

#ifndef GOOGLE_PROTOBUF_INCLUDED_rule_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_rule_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 "sdk.pb.h"
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_rule_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_rule_2eproto {
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[4]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_rule_2eproto;
namespace protomsg {
class RuleBaseCompareInfo;
struct RuleBaseCompareInfoDefaultTypeInternal;
extern RuleBaseCompareInfoDefaultTypeInternal _RuleBaseCompareInfo_default_instance_;
class RuleSOResult;
struct RuleSOResultDefaultTypeInternal;
extern RuleSOResultDefaultTypeInternal _RuleSOResult_default_instance_;
class RuleSoTarget;
struct RuleSoTargetDefaultTypeInternal;
extern RuleSoTargetDefaultTypeInternal _RuleSoTarget_default_instance_;
class RuleTargets;
struct RuleTargetsDefaultTypeInternal;
extern RuleTargetsDefaultTypeInternal _RuleTargets_default_instance_;
}  // namespace protomsg
PROTOBUF_NAMESPACE_OPEN
template<> ::protomsg::RuleBaseCompareInfo* Arena::CreateMaybeMessage<::protomsg::RuleBaseCompareInfo>(Arena*);
template<> ::protomsg::RuleSOResult* Arena::CreateMaybeMessage<::protomsg::RuleSOResult>(Arena*);
template<> ::protomsg::RuleSoTarget* Arena::CreateMaybeMessage<::protomsg::RuleSoTarget>(Arena*);
template<> ::protomsg::RuleTargets* Arena::CreateMaybeMessage<::protomsg::RuleTargets>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace protomsg {

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

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

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

  inline RuleTargets& operator=(const RuleTargets& from) {
    CopyFrom(from);
    return *this;
  }
  inline RuleTargets& operator=(RuleTargets&& 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 RuleTargets& default_instance() {
    return *internal_default_instance();
  }
  static inline const RuleTargets* internal_default_instance() {
    return reinterpret_cast<const RuleTargets*>(
               &_RuleTargets_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

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

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

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

  RuleTargets* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<RuleTargets>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const RuleTargets& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const RuleTargets& 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(RuleTargets* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "protomsg.RuleTargets";
  }
  protected:
  explicit RuleTargets(::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 {
    kTargetFieldNumber = 1,
  };
  // repeated .protomsg.Target target = 1;
  int target_size() const;
  private:
  int _internal_target_size() const;
  public:
  void clear_target();
  ::protomsg::Target* mutable_target(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::protomsg::Target >*
      mutable_target();
  private:
  const ::protomsg::Target& _internal_target(int index) const;
  ::protomsg::Target* _internal_add_target();
  public:
  const ::protomsg::Target& target(int index) const;
  ::protomsg::Target* add_target();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::protomsg::Target >&
      target() const;

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::protomsg::Target > target_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_rule_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline RuleSOResult& operator=(const RuleSOResult& from) {
    CopyFrom(from);
    return *this;
  }
  inline RuleSOResult& operator=(RuleSOResult&& 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 RuleSOResult& default_instance() {
    return *internal_default_instance();
  }
  static inline const RuleSOResult* internal_default_instance() {
    return reinterpret_cast<const RuleSOResult*>(
               &_RuleSOResult_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

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

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

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

  RuleSOResult* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<RuleSOResult>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const RuleSOResult& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const RuleSOResult& 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(RuleSOResult* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "protomsg.RuleSOResult";
  }
  protected:
  explicit RuleSOResult(::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 {
    kTargetsFieldNumber = 3,
    kSoTypeFieldNumber = 5,
    kCacheImageFieldNumber = 4,
    kIsEventFieldNumber = 1,
    kIsEndRecordFieldNumber = 2,
  };
  // repeated .protomsg.RuleSoTarget targets = 3;
  int targets_size() const;
  private:
  int _internal_targets_size() const;
  public:
  void clear_targets();
  ::protomsg::RuleSoTarget* mutable_targets(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::protomsg::RuleSoTarget >*
      mutable_targets();
  private:
  const ::protomsg::RuleSoTarget& _internal_targets(int index) const;
  ::protomsg::RuleSoTarget* _internal_add_targets();
  public:
  const ::protomsg::RuleSoTarget& targets(int index) const;
  ::protomsg::RuleSoTarget* add_targets();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::protomsg::RuleSoTarget >&
      targets() const;

  // string soType = 5;
  void clear_sotype();
  const std::string& sotype() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_sotype(ArgT0&& arg0, ArgT... args);
  std::string* mutable_sotype();
  PROTOBUF_MUST_USE_RESULT std::string* release_sotype();
  void set_allocated_sotype(std::string* sotype);
  private:
  const std::string& _internal_sotype() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_sotype(const std::string& value);
  std::string* _internal_mutable_sotype();
  public:

  // .protomsg.Image cacheImage = 4;
  bool has_cacheimage() const;
  private:
  bool _internal_has_cacheimage() const;
  public:
  void clear_cacheimage();
  const ::protomsg::Image& cacheimage() const;
  PROTOBUF_MUST_USE_RESULT ::protomsg::Image* release_cacheimage();
  ::protomsg::Image* mutable_cacheimage();
  void set_allocated_cacheimage(::protomsg::Image* cacheimage);
  private:
  const ::protomsg::Image& _internal_cacheimage() const;
  ::protomsg::Image* _internal_mutable_cacheimage();
  public:
  void unsafe_arena_set_allocated_cacheimage(
      ::protomsg::Image* cacheimage);
  ::protomsg::Image* unsafe_arena_release_cacheimage();

  // bool IsEvent = 1;
  void clear_isevent();
  bool isevent() const;
  void set_isevent(bool value);
  private:
  bool _internal_isevent() const;
  void _internal_set_isevent(bool value);
  public:

  // bool IsEndRecord = 2;
  void clear_isendrecord();
  bool isendrecord() const;
  void set_isendrecord(bool value);
  private:
  bool _internal_isendrecord() const;
  void _internal_set_isendrecord(bool value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::protomsg::RuleSoTarget > targets_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr sotype_;
  ::protomsg::Image* cacheimage_;
  bool isevent_;
  bool isendrecord_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_rule_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline RuleSoTarget& operator=(const RuleSoTarget& from) {
    CopyFrom(from);
    return *this;
  }
  inline RuleSoTarget& operator=(RuleSoTarget&& 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 RuleSoTarget& default_instance() {
    return *internal_default_instance();
  }
  static inline const RuleSoTarget* internal_default_instance() {
    return reinterpret_cast<const RuleSoTarget*>(
               &_RuleSoTarget_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

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

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

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

  RuleSoTarget* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<RuleSoTarget>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const RuleSoTarget& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const RuleSoTarget& 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(RuleSoTarget* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "protomsg.RuleSoTarget";
  }
  protected:
  explicit RuleSoTarget(::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 {
    kCompDbInfoFieldNumber = 5,
    kAreaIdFieldNumber = 2,
    kAreaNameFieldNumber = 3,
    kBelongsTargetIDFieldNumber = 4,
    kSrcTargetFieldNumber = 1,
    kImageIdFieldNumber = 6,
  };
  // repeated .protomsg.RuleBaseCompareInfo compDbInfo = 5;
  int compdbinfo_size() const;
  private:
  int _internal_compdbinfo_size() const;
  public:
  void clear_compdbinfo();
  ::protomsg::RuleBaseCompareInfo* mutable_compdbinfo(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::protomsg::RuleBaseCompareInfo >*
      mutable_compdbinfo();
  private:
  const ::protomsg::RuleBaseCompareInfo& _internal_compdbinfo(int index) const;
  ::protomsg::RuleBaseCompareInfo* _internal_add_compdbinfo();
  public:
  const ::protomsg::RuleBaseCompareInfo& compdbinfo(int index) const;
  ::protomsg::RuleBaseCompareInfo* add_compdbinfo();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::protomsg::RuleBaseCompareInfo >&
      compdbinfo() const;

  // string areaId = 2;
  void clear_areaid();
  const std::string& areaid() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_areaid(ArgT0&& arg0, ArgT... args);
  std::string* mutable_areaid();
  PROTOBUF_MUST_USE_RESULT std::string* release_areaid();
  void set_allocated_areaid(std::string* areaid);
  private:
  const std::string& _internal_areaid() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_areaid(const std::string& value);
  std::string* _internal_mutable_areaid();
  public:

  // string areaName = 3;
  void clear_areaname();
  const std::string& areaname() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_areaname(ArgT0&& arg0, ArgT... args);
  std::string* mutable_areaname();
  PROTOBUF_MUST_USE_RESULT std::string* release_areaname();
  void set_allocated_areaname(std::string* areaname);
  private:
  const std::string& _internal_areaname() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_areaname(const std::string& value);
  std::string* _internal_mutable_areaname();
  public:

  // string belongsTargetID = 4;
  void clear_belongstargetid();
  const std::string& belongstargetid() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_belongstargetid(ArgT0&& arg0, ArgT... args);
  std::string* mutable_belongstargetid();
  PROTOBUF_MUST_USE_RESULT std::string* release_belongstargetid();
  void set_allocated_belongstargetid(std::string* belongstargetid);
  private:
  const std::string& _internal_belongstargetid() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_belongstargetid(const std::string& value);
  std::string* _internal_mutable_belongstargetid();
  public:

  // .protomsg.Target srcTarget = 1;
  bool has_srctarget() const;
  private:
  bool _internal_has_srctarget() const;
  public:
  void clear_srctarget();
  const ::protomsg::Target& srctarget() const;
  PROTOBUF_MUST_USE_RESULT ::protomsg::Target* release_srctarget();
  ::protomsg::Target* mutable_srctarget();
  void set_allocated_srctarget(::protomsg::Target* srctarget);
  private:
  const ::protomsg::Target& _internal_srctarget() const;
  ::protomsg::Target* _internal_mutable_srctarget();
  public:
  void unsafe_arena_set_allocated_srctarget(
      ::protomsg::Target* srctarget);
  ::protomsg::Target* unsafe_arena_release_srctarget();

  // int64 imageId = 6;
  void clear_imageid();
  ::PROTOBUF_NAMESPACE_ID::int64 imageid() const;
  void set_imageid(::PROTOBUF_NAMESPACE_ID::int64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_imageid() const;
  void _internal_set_imageid(::PROTOBUF_NAMESPACE_ID::int64 value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::protomsg::RuleBaseCompareInfo > compdbinfo_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr areaid_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr areaname_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr belongstargetid_;
  ::protomsg::Target* srctarget_;
  ::PROTOBUF_NAMESPACE_ID::int64 imageid_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_rule_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline RuleBaseCompareInfo& operator=(const RuleBaseCompareInfo& from) {
    CopyFrom(from);
    return *this;
  }
  inline RuleBaseCompareInfo& operator=(RuleBaseCompareInfo&& 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 RuleBaseCompareInfo& default_instance() {
    return *internal_default_instance();
  }
  static inline const RuleBaseCompareInfo* internal_default_instance() {
    return reinterpret_cast<const RuleBaseCompareInfo*>(
               &_RuleBaseCompareInfo_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

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

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

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

  RuleBaseCompareInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<RuleBaseCompareInfo>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const RuleBaseCompareInfo& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const RuleBaseCompareInfo& 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(RuleBaseCompareInfo* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "protomsg.RuleBaseCompareInfo";
  }
  protected:
  explicit RuleBaseCompareInfo(::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 {
    kTableIdFieldNumber = 1,
    kTableNameFieldNumber = 2,
    kBwTypeFieldNumber = 3,
    kCompareScoreFieldNumber = 4,
    kTargetIdFieldNumber = 5,
    kTargetNameFieldNumber = 6,
    kTargetPicUrlFieldNumber = 7,
    kMonitorLevelFieldNumber = 8,
    kContentFieldNumber = 9,
    kDbLabelFieldNumber = 10,
  };
  // string TableId = 1;
  void clear_tableid();
  const std::string& tableid() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_tableid(ArgT0&& arg0, ArgT... args);
  std::string* mutable_tableid();
  PROTOBUF_MUST_USE_RESULT std::string* release_tableid();
  void set_allocated_tableid(std::string* tableid);
  private:
  const std::string& _internal_tableid() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_tableid(const std::string& value);
  std::string* _internal_mutable_tableid();
  public:

  // string TableName = 2;
  void clear_tablename();
  const std::string& tablename() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_tablename(ArgT0&& arg0, ArgT... args);
  std::string* mutable_tablename();
  PROTOBUF_MUST_USE_RESULT std::string* release_tablename();
  void set_allocated_tablename(std::string* tablename);
  private:
  const std::string& _internal_tablename() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_tablename(const std::string& value);
  std::string* _internal_mutable_tablename();
  public:

  // string BwType = 3;
  void clear_bwtype();
  const std::string& bwtype() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_bwtype(ArgT0&& arg0, ArgT... args);
  std::string* mutable_bwtype();
  PROTOBUF_MUST_USE_RESULT std::string* release_bwtype();
  void set_allocated_bwtype(std::string* bwtype);
  private:
  const std::string& _internal_bwtype() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_bwtype(const std::string& value);
  std::string* _internal_mutable_bwtype();
  public:

  // string CompareScore = 4;
  void clear_comparescore();
  const std::string& comparescore() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_comparescore(ArgT0&& arg0, ArgT... args);
  std::string* mutable_comparescore();
  PROTOBUF_MUST_USE_RESULT std::string* release_comparescore();
  void set_allocated_comparescore(std::string* comparescore);
  private:
  const std::string& _internal_comparescore() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_comparescore(const std::string& value);
  std::string* _internal_mutable_comparescore();
  public:

  // string TargetId = 5;
  void clear_targetid();
  const std::string& targetid() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_targetid(ArgT0&& arg0, ArgT... args);
  std::string* mutable_targetid();
  PROTOBUF_MUST_USE_RESULT std::string* release_targetid();
  void set_allocated_targetid(std::string* targetid);
  private:
  const std::string& _internal_targetid() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_targetid(const std::string& value);
  std::string* _internal_mutable_targetid();
  public:

  // string TargetName = 6;
  void clear_targetname();
  const std::string& targetname() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_targetname(ArgT0&& arg0, ArgT... args);
  std::string* mutable_targetname();
  PROTOBUF_MUST_USE_RESULT std::string* release_targetname();
  void set_allocated_targetname(std::string* targetname);
  private:
  const std::string& _internal_targetname() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_targetname(const std::string& value);
  std::string* _internal_mutable_targetname();
  public:

  // string TargetPicUrl = 7;
  void clear_targetpicurl();
  const std::string& targetpicurl() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_targetpicurl(ArgT0&& arg0, ArgT... args);
  std::string* mutable_targetpicurl();
  PROTOBUF_MUST_USE_RESULT std::string* release_targetpicurl();
  void set_allocated_targetpicurl(std::string* targetpicurl);
  private:
  const std::string& _internal_targetpicurl() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_targetpicurl(const std::string& value);
  std::string* _internal_mutable_targetpicurl();
  public:

  // string MonitorLevel = 8;
  void clear_monitorlevel();
  const std::string& monitorlevel() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_monitorlevel(ArgT0&& arg0, ArgT... args);
  std::string* mutable_monitorlevel();
  PROTOBUF_MUST_USE_RESULT std::string* release_monitorlevel();
  void set_allocated_monitorlevel(std::string* monitorlevel);
  private:
  const std::string& _internal_monitorlevel() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_monitorlevel(const std::string& value);
  std::string* _internal_mutable_monitorlevel();
  public:

  // string Content = 9;
  void clear_content();
  const std::string& content() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_content(ArgT0&& arg0, ArgT... args);
  std::string* mutable_content();
  PROTOBUF_MUST_USE_RESULT std::string* release_content();
  void set_allocated_content(std::string* content);
  private:
  const std::string& _internal_content() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_content(const std::string& value);
  std::string* _internal_mutable_content();
  public:

  // string DbLabel = 10;
  void clear_dblabel();
  const std::string& dblabel() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_dblabel(ArgT0&& arg0, ArgT... args);
  std::string* mutable_dblabel();
  PROTOBUF_MUST_USE_RESULT std::string* release_dblabel();
  void set_allocated_dblabel(std::string* dblabel);
  private:
  const std::string& _internal_dblabel() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_dblabel(const std::string& value);
  std::string* _internal_mutable_dblabel();
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr tableid_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr tablename_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr bwtype_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr comparescore_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr targetid_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr targetname_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr targetpicurl_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr monitorlevel_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr content_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr dblabel_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_rule_2eproto;
};
// ===================================================================


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

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

// repeated .protomsg.Target target = 1;
inline int RuleTargets::_internal_target_size() const {
  return target_.size();
}
inline int RuleTargets::target_size() const {
  return _internal_target_size();
}
inline ::protomsg::Target* RuleTargets::mutable_target(int index) {
  // @@protoc_insertion_point(field_mutable:protomsg.RuleTargets.target)
  return target_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::protomsg::Target >*
RuleTargets::mutable_target() {
  // @@protoc_insertion_point(field_mutable_list:protomsg.RuleTargets.target)
  return &target_;
}
inline const ::protomsg::Target& RuleTargets::_internal_target(int index) const {
  return target_.Get(index);
}
inline const ::protomsg::Target& RuleTargets::target(int index) const {
  // @@protoc_insertion_point(field_get:protomsg.RuleTargets.target)
  return _internal_target(index);
}
inline ::protomsg::Target* RuleTargets::_internal_add_target() {
  return target_.Add();
}
inline ::protomsg::Target* RuleTargets::add_target() {
  ::protomsg::Target* _add = _internal_add_target();
  // @@protoc_insertion_point(field_add:protomsg.RuleTargets.target)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::protomsg::Target >&
RuleTargets::target() const {
  // @@protoc_insertion_point(field_list:protomsg.RuleTargets.target)
  return target_;
}

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

// RuleSOResult

// bool IsEvent = 1;
inline void RuleSOResult::clear_isevent() {
  isevent_ = false;
}
inline bool RuleSOResult::_internal_isevent() const {
  return isevent_;
}
inline bool RuleSOResult::isevent() const {
  // @@protoc_insertion_point(field_get:protomsg.RuleSOResult.IsEvent)
  return _internal_isevent();
}
inline void RuleSOResult::_internal_set_isevent(bool value) {
  
  isevent_ = value;
}
inline void RuleSOResult::set_isevent(bool value) {
  _internal_set_isevent(value);
  // @@protoc_insertion_point(field_set:protomsg.RuleSOResult.IsEvent)
}

// bool IsEndRecord = 2;
inline void RuleSOResult::clear_isendrecord() {
  isendrecord_ = false;
}
inline bool RuleSOResult::_internal_isendrecord() const {
  return isendrecord_;
}
inline bool RuleSOResult::isendrecord() const {
  // @@protoc_insertion_point(field_get:protomsg.RuleSOResult.IsEndRecord)
  return _internal_isendrecord();
}
inline void RuleSOResult::_internal_set_isendrecord(bool value) {
  
  isendrecord_ = value;
}
inline void RuleSOResult::set_isendrecord(bool value) {
  _internal_set_isendrecord(value);
  // @@protoc_insertion_point(field_set:protomsg.RuleSOResult.IsEndRecord)
}

// repeated .protomsg.RuleSoTarget targets = 3;
inline int RuleSOResult::_internal_targets_size() const {
  return targets_.size();
}
inline int RuleSOResult::targets_size() const {
  return _internal_targets_size();
}
inline void RuleSOResult::clear_targets() {
  targets_.Clear();
}
inline ::protomsg::RuleSoTarget* RuleSOResult::mutable_targets(int index) {
  // @@protoc_insertion_point(field_mutable:protomsg.RuleSOResult.targets)
  return targets_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::protomsg::RuleSoTarget >*
RuleSOResult::mutable_targets() {
  // @@protoc_insertion_point(field_mutable_list:protomsg.RuleSOResult.targets)
  return &targets_;
}
inline const ::protomsg::RuleSoTarget& RuleSOResult::_internal_targets(int index) const {
  return targets_.Get(index);
}
inline const ::protomsg::RuleSoTarget& RuleSOResult::targets(int index) const {
  // @@protoc_insertion_point(field_get:protomsg.RuleSOResult.targets)
  return _internal_targets(index);
}
inline ::protomsg::RuleSoTarget* RuleSOResult::_internal_add_targets() {
  return targets_.Add();
}
inline ::protomsg::RuleSoTarget* RuleSOResult::add_targets() {
  ::protomsg::RuleSoTarget* _add = _internal_add_targets();
  // @@protoc_insertion_point(field_add:protomsg.RuleSOResult.targets)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::protomsg::RuleSoTarget >&
RuleSOResult::targets() const {
  // @@protoc_insertion_point(field_list:protomsg.RuleSOResult.targets)
  return targets_;
}

// .protomsg.Image cacheImage = 4;
inline bool RuleSOResult::_internal_has_cacheimage() const {
  return this != internal_default_instance() && cacheimage_ != nullptr;
}
inline bool RuleSOResult::has_cacheimage() const {
  return _internal_has_cacheimage();
}
inline const ::protomsg::Image& RuleSOResult::_internal_cacheimage() const {
  const ::protomsg::Image* p = cacheimage_;
  return p != nullptr ? *p : reinterpret_cast<const ::protomsg::Image&>(
      ::protomsg::_Image_default_instance_);
}
inline const ::protomsg::Image& RuleSOResult::cacheimage() const {
  // @@protoc_insertion_point(field_get:protomsg.RuleSOResult.cacheImage)
  return _internal_cacheimage();
}
inline void RuleSOResult::unsafe_arena_set_allocated_cacheimage(
    ::protomsg::Image* cacheimage) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(cacheimage_);
  }
  cacheimage_ = cacheimage;
  if (cacheimage) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protomsg.RuleSOResult.cacheImage)
}
inline ::protomsg::Image* RuleSOResult::release_cacheimage() {
  
  ::protomsg::Image* temp = cacheimage_;
  cacheimage_ = 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::Image* RuleSOResult::unsafe_arena_release_cacheimage() {
  // @@protoc_insertion_point(field_release:protomsg.RuleSOResult.cacheImage)
  
  ::protomsg::Image* temp = cacheimage_;
  cacheimage_ = nullptr;
  return temp;
}
inline ::protomsg::Image* RuleSOResult::_internal_mutable_cacheimage() {
  
  if (cacheimage_ == nullptr) {
    auto* p = CreateMaybeMessage<::protomsg::Image>(GetArenaForAllocation());
    cacheimage_ = p;
  }
  return cacheimage_;
}
inline ::protomsg::Image* RuleSOResult::mutable_cacheimage() {
  ::protomsg::Image* _msg = _internal_mutable_cacheimage();
  // @@protoc_insertion_point(field_mutable:protomsg.RuleSOResult.cacheImage)
  return _msg;
}
inline void RuleSOResult::set_allocated_cacheimage(::protomsg::Image* cacheimage) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(cacheimage_);
  }
  if (cacheimage) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(cacheimage));
    if (message_arena != submessage_arena) {
      cacheimage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, cacheimage, submessage_arena);
    }
    
  } else {
    
  }
  cacheimage_ = cacheimage;
  // @@protoc_insertion_point(field_set_allocated:protomsg.RuleSOResult.cacheImage)
}

// string soType = 5;
inline void RuleSOResult::clear_sotype() {
  sotype_.ClearToEmpty();
}
inline const std::string& RuleSOResult::sotype() const {
  // @@protoc_insertion_point(field_get:protomsg.RuleSOResult.soType)
  return _internal_sotype();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RuleSOResult::set_sotype(ArgT0&& arg0, ArgT... args) {
 
 sotype_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:protomsg.RuleSOResult.soType)
}
inline std::string* RuleSOResult::mutable_sotype() {
  std::string* _s = _internal_mutable_sotype();
  // @@protoc_insertion_point(field_mutable:protomsg.RuleSOResult.soType)
  return _s;
}
inline const std::string& RuleSOResult::_internal_sotype() const {
  return sotype_.Get();
}
inline void RuleSOResult::_internal_set_sotype(const std::string& value) {
  
  sotype_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* RuleSOResult::_internal_mutable_sotype() {
  
  return sotype_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* RuleSOResult::release_sotype() {
  // @@protoc_insertion_point(field_release:protomsg.RuleSOResult.soType)
  return sotype_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void RuleSOResult::set_allocated_sotype(std::string* sotype) {
  if (sotype != nullptr) {
    
  } else {
    
  }
  sotype_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), sotype,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:protomsg.RuleSOResult.soType)
}

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

// RuleSoTarget

// .protomsg.Target srcTarget = 1;
inline bool RuleSoTarget::_internal_has_srctarget() const {
  return this != internal_default_instance() && srctarget_ != nullptr;
}
inline bool RuleSoTarget::has_srctarget() const {
  return _internal_has_srctarget();
}
inline const ::protomsg::Target& RuleSoTarget::_internal_srctarget() const {
  const ::protomsg::Target* p = srctarget_;
  return p != nullptr ? *p : reinterpret_cast<const ::protomsg::Target&>(
      ::protomsg::_Target_default_instance_);
}
inline const ::protomsg::Target& RuleSoTarget::srctarget() const {
  // @@protoc_insertion_point(field_get:protomsg.RuleSoTarget.srcTarget)
  return _internal_srctarget();
}
inline void RuleSoTarget::unsafe_arena_set_allocated_srctarget(
    ::protomsg::Target* srctarget) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(srctarget_);
  }
  srctarget_ = srctarget;
  if (srctarget) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protomsg.RuleSoTarget.srcTarget)
}
inline ::protomsg::Target* RuleSoTarget::release_srctarget() {
  
  ::protomsg::Target* temp = srctarget_;
  srctarget_ = 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::Target* RuleSoTarget::unsafe_arena_release_srctarget() {
  // @@protoc_insertion_point(field_release:protomsg.RuleSoTarget.srcTarget)
  
  ::protomsg::Target* temp = srctarget_;
  srctarget_ = nullptr;
  return temp;
}
inline ::protomsg::Target* RuleSoTarget::_internal_mutable_srctarget() {
  
  if (srctarget_ == nullptr) {
    auto* p = CreateMaybeMessage<::protomsg::Target>(GetArenaForAllocation());
    srctarget_ = p;
  }
  return srctarget_;
}
inline ::protomsg::Target* RuleSoTarget::mutable_srctarget() {
  ::protomsg::Target* _msg = _internal_mutable_srctarget();
  // @@protoc_insertion_point(field_mutable:protomsg.RuleSoTarget.srcTarget)
  return _msg;
}
inline void RuleSoTarget::set_allocated_srctarget(::protomsg::Target* srctarget) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(srctarget_);
  }
  if (srctarget) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(srctarget));
    if (message_arena != submessage_arena) {
      srctarget = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, srctarget, submessage_arena);
    }
    
  } else {
    
  }
  srctarget_ = srctarget;
  // @@protoc_insertion_point(field_set_allocated:protomsg.RuleSoTarget.srcTarget)
}

// string areaId = 2;
inline void RuleSoTarget::clear_areaid() {
  areaid_.ClearToEmpty();
}
inline const std::string& RuleSoTarget::areaid() const {
  // @@protoc_insertion_point(field_get:protomsg.RuleSoTarget.areaId)
  return _internal_areaid();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RuleSoTarget::set_areaid(ArgT0&& arg0, ArgT... args) {
 
 areaid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:protomsg.RuleSoTarget.areaId)
}
inline std::string* RuleSoTarget::mutable_areaid() {
  std::string* _s = _internal_mutable_areaid();
  // @@protoc_insertion_point(field_mutable:protomsg.RuleSoTarget.areaId)
  return _s;
}
inline const std::string& RuleSoTarget::_internal_areaid() const {
  return areaid_.Get();
}
inline void RuleSoTarget::_internal_set_areaid(const std::string& value) {
  
  areaid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* RuleSoTarget::_internal_mutable_areaid() {
  
  return areaid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* RuleSoTarget::release_areaid() {
  // @@protoc_insertion_point(field_release:protomsg.RuleSoTarget.areaId)
  return areaid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void RuleSoTarget::set_allocated_areaid(std::string* areaid) {
  if (areaid != nullptr) {
    
  } else {
    
  }
  areaid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), areaid,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:protomsg.RuleSoTarget.areaId)
}

// string areaName = 3;
inline void RuleSoTarget::clear_areaname() {
  areaname_.ClearToEmpty();
}
inline const std::string& RuleSoTarget::areaname() const {
  // @@protoc_insertion_point(field_get:protomsg.RuleSoTarget.areaName)
  return _internal_areaname();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RuleSoTarget::set_areaname(ArgT0&& arg0, ArgT... args) {
 
 areaname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:protomsg.RuleSoTarget.areaName)
}
inline std::string* RuleSoTarget::mutable_areaname() {
  std::string* _s = _internal_mutable_areaname();
  // @@protoc_insertion_point(field_mutable:protomsg.RuleSoTarget.areaName)
  return _s;
}
inline const std::string& RuleSoTarget::_internal_areaname() const {
  return areaname_.Get();
}
inline void RuleSoTarget::_internal_set_areaname(const std::string& value) {
  
  areaname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* RuleSoTarget::_internal_mutable_areaname() {
  
  return areaname_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* RuleSoTarget::release_areaname() {
  // @@protoc_insertion_point(field_release:protomsg.RuleSoTarget.areaName)
  return areaname_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void RuleSoTarget::set_allocated_areaname(std::string* areaname) {
  if (areaname != nullptr) {
    
  } else {
    
  }
  areaname_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), areaname,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:protomsg.RuleSoTarget.areaName)
}

// string belongsTargetID = 4;
inline void RuleSoTarget::clear_belongstargetid() {
  belongstargetid_.ClearToEmpty();
}
inline const std::string& RuleSoTarget::belongstargetid() const {
  // @@protoc_insertion_point(field_get:protomsg.RuleSoTarget.belongsTargetID)
  return _internal_belongstargetid();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RuleSoTarget::set_belongstargetid(ArgT0&& arg0, ArgT... args) {
 
 belongstargetid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:protomsg.RuleSoTarget.belongsTargetID)
}
inline std::string* RuleSoTarget::mutable_belongstargetid() {
  std::string* _s = _internal_mutable_belongstargetid();
  // @@protoc_insertion_point(field_mutable:protomsg.RuleSoTarget.belongsTargetID)
  return _s;
}
inline const std::string& RuleSoTarget::_internal_belongstargetid() const {
  return belongstargetid_.Get();
}
inline void RuleSoTarget::_internal_set_belongstargetid(const std::string& value) {
  
  belongstargetid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* RuleSoTarget::_internal_mutable_belongstargetid() {
  
  return belongstargetid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* RuleSoTarget::release_belongstargetid() {
  // @@protoc_insertion_point(field_release:protomsg.RuleSoTarget.belongsTargetID)
  return belongstargetid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void RuleSoTarget::set_allocated_belongstargetid(std::string* belongstargetid) {
  if (belongstargetid != nullptr) {
    
  } else {
    
  }
  belongstargetid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), belongstargetid,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:protomsg.RuleSoTarget.belongsTargetID)
}

// repeated .protomsg.RuleBaseCompareInfo compDbInfo = 5;
inline int RuleSoTarget::_internal_compdbinfo_size() const {
  return compdbinfo_.size();
}
inline int RuleSoTarget::compdbinfo_size() const {
  return _internal_compdbinfo_size();
}
inline void RuleSoTarget::clear_compdbinfo() {
  compdbinfo_.Clear();
}
inline ::protomsg::RuleBaseCompareInfo* RuleSoTarget::mutable_compdbinfo(int index) {
  // @@protoc_insertion_point(field_mutable:protomsg.RuleSoTarget.compDbInfo)
  return compdbinfo_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::protomsg::RuleBaseCompareInfo >*
RuleSoTarget::mutable_compdbinfo() {
  // @@protoc_insertion_point(field_mutable_list:protomsg.RuleSoTarget.compDbInfo)
  return &compdbinfo_;
}
inline const ::protomsg::RuleBaseCompareInfo& RuleSoTarget::_internal_compdbinfo(int index) const {
  return compdbinfo_.Get(index);
}
inline const ::protomsg::RuleBaseCompareInfo& RuleSoTarget::compdbinfo(int index) const {
  // @@protoc_insertion_point(field_get:protomsg.RuleSoTarget.compDbInfo)
  return _internal_compdbinfo(index);
}
inline ::protomsg::RuleBaseCompareInfo* RuleSoTarget::_internal_add_compdbinfo() {
  return compdbinfo_.Add();
}
inline ::protomsg::RuleBaseCompareInfo* RuleSoTarget::add_compdbinfo() {
  ::protomsg::RuleBaseCompareInfo* _add = _internal_add_compdbinfo();
  // @@protoc_insertion_point(field_add:protomsg.RuleSoTarget.compDbInfo)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::protomsg::RuleBaseCompareInfo >&
RuleSoTarget::compdbinfo() const {
  // @@protoc_insertion_point(field_list:protomsg.RuleSoTarget.compDbInfo)
  return compdbinfo_;
}

// int64 imageId = 6;
inline void RuleSoTarget::clear_imageid() {
  imageid_ = int64_t{0};
}
inline ::PROTOBUF_NAMESPACE_ID::int64 RuleSoTarget::_internal_imageid() const {
  return imageid_;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 RuleSoTarget::imageid() const {
  // @@protoc_insertion_point(field_get:protomsg.RuleSoTarget.imageId)
  return _internal_imageid();
}
inline void RuleSoTarget::_internal_set_imageid(::PROTOBUF_NAMESPACE_ID::int64 value) {
  
  imageid_ = value;
}
inline void RuleSoTarget::set_imageid(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_set_imageid(value);
  // @@protoc_insertion_point(field_set:protomsg.RuleSoTarget.imageId)
}

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

// RuleBaseCompareInfo

// string TableId = 1;
inline void RuleBaseCompareInfo::clear_tableid() {
  tableid_.ClearToEmpty();
}
inline const std::string& RuleBaseCompareInfo::tableid() const {
  // @@protoc_insertion_point(field_get:protomsg.RuleBaseCompareInfo.TableId)
  return _internal_tableid();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RuleBaseCompareInfo::set_tableid(ArgT0&& arg0, ArgT... args) {
 
 tableid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:protomsg.RuleBaseCompareInfo.TableId)
}
inline std::string* RuleBaseCompareInfo::mutable_tableid() {
  std::string* _s = _internal_mutable_tableid();
  // @@protoc_insertion_point(field_mutable:protomsg.RuleBaseCompareInfo.TableId)
  return _s;
}
inline const std::string& RuleBaseCompareInfo::_internal_tableid() const {
  return tableid_.Get();
}
inline void RuleBaseCompareInfo::_internal_set_tableid(const std::string& value) {
  
  tableid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* RuleBaseCompareInfo::_internal_mutable_tableid() {
  
  return tableid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* RuleBaseCompareInfo::release_tableid() {
  // @@protoc_insertion_point(field_release:protomsg.RuleBaseCompareInfo.TableId)
  return tableid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void RuleBaseCompareInfo::set_allocated_tableid(std::string* tableid) {
  if (tableid != nullptr) {
    
  } else {
    
  }
  tableid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), tableid,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:protomsg.RuleBaseCompareInfo.TableId)
}

// string TableName = 2;
inline void RuleBaseCompareInfo::clear_tablename() {
  tablename_.ClearToEmpty();
}
inline const std::string& RuleBaseCompareInfo::tablename() const {
  // @@protoc_insertion_point(field_get:protomsg.RuleBaseCompareInfo.TableName)
  return _internal_tablename();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RuleBaseCompareInfo::set_tablename(ArgT0&& arg0, ArgT... args) {
 
 tablename_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:protomsg.RuleBaseCompareInfo.TableName)
}
inline std::string* RuleBaseCompareInfo::mutable_tablename() {
  std::string* _s = _internal_mutable_tablename();
  // @@protoc_insertion_point(field_mutable:protomsg.RuleBaseCompareInfo.TableName)
  return _s;
}
inline const std::string& RuleBaseCompareInfo::_internal_tablename() const {
  return tablename_.Get();
}
inline void RuleBaseCompareInfo::_internal_set_tablename(const std::string& value) {
  
  tablename_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* RuleBaseCompareInfo::_internal_mutable_tablename() {
  
  return tablename_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* RuleBaseCompareInfo::release_tablename() {
  // @@protoc_insertion_point(field_release:protomsg.RuleBaseCompareInfo.TableName)
  return tablename_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void RuleBaseCompareInfo::set_allocated_tablename(std::string* tablename) {
  if (tablename != nullptr) {
    
  } else {
    
  }
  tablename_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), tablename,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:protomsg.RuleBaseCompareInfo.TableName)
}

// string BwType = 3;
inline void RuleBaseCompareInfo::clear_bwtype() {
  bwtype_.ClearToEmpty();
}
inline const std::string& RuleBaseCompareInfo::bwtype() const {
  // @@protoc_insertion_point(field_get:protomsg.RuleBaseCompareInfo.BwType)
  return _internal_bwtype();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RuleBaseCompareInfo::set_bwtype(ArgT0&& arg0, ArgT... args) {
 
 bwtype_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:protomsg.RuleBaseCompareInfo.BwType)
}
inline std::string* RuleBaseCompareInfo::mutable_bwtype() {
  std::string* _s = _internal_mutable_bwtype();
  // @@protoc_insertion_point(field_mutable:protomsg.RuleBaseCompareInfo.BwType)
  return _s;
}
inline const std::string& RuleBaseCompareInfo::_internal_bwtype() const {
  return bwtype_.Get();
}
inline void RuleBaseCompareInfo::_internal_set_bwtype(const std::string& value) {
  
  bwtype_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* RuleBaseCompareInfo::_internal_mutable_bwtype() {
  
  return bwtype_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* RuleBaseCompareInfo::release_bwtype() {
  // @@protoc_insertion_point(field_release:protomsg.RuleBaseCompareInfo.BwType)
  return bwtype_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void RuleBaseCompareInfo::set_allocated_bwtype(std::string* bwtype) {
  if (bwtype != nullptr) {
    
  } else {
    
  }
  bwtype_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), bwtype,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:protomsg.RuleBaseCompareInfo.BwType)
}

// string CompareScore = 4;
inline void RuleBaseCompareInfo::clear_comparescore() {
  comparescore_.ClearToEmpty();
}
inline const std::string& RuleBaseCompareInfo::comparescore() const {
  // @@protoc_insertion_point(field_get:protomsg.RuleBaseCompareInfo.CompareScore)
  return _internal_comparescore();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RuleBaseCompareInfo::set_comparescore(ArgT0&& arg0, ArgT... args) {
 
 comparescore_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:protomsg.RuleBaseCompareInfo.CompareScore)
}
inline std::string* RuleBaseCompareInfo::mutable_comparescore() {
  std::string* _s = _internal_mutable_comparescore();
  // @@protoc_insertion_point(field_mutable:protomsg.RuleBaseCompareInfo.CompareScore)
  return _s;
}
inline const std::string& RuleBaseCompareInfo::_internal_comparescore() const {
  return comparescore_.Get();
}
inline void RuleBaseCompareInfo::_internal_set_comparescore(const std::string& value) {
  
  comparescore_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* RuleBaseCompareInfo::_internal_mutable_comparescore() {
  
  return comparescore_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* RuleBaseCompareInfo::release_comparescore() {
  // @@protoc_insertion_point(field_release:protomsg.RuleBaseCompareInfo.CompareScore)
  return comparescore_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void RuleBaseCompareInfo::set_allocated_comparescore(std::string* comparescore) {
  if (comparescore != nullptr) {
    
  } else {
    
  }
  comparescore_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), comparescore,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:protomsg.RuleBaseCompareInfo.CompareScore)
}

// string TargetId = 5;
inline void RuleBaseCompareInfo::clear_targetid() {
  targetid_.ClearToEmpty();
}
inline const std::string& RuleBaseCompareInfo::targetid() const {
  // @@protoc_insertion_point(field_get:protomsg.RuleBaseCompareInfo.TargetId)
  return _internal_targetid();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RuleBaseCompareInfo::set_targetid(ArgT0&& arg0, ArgT... args) {
 
 targetid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:protomsg.RuleBaseCompareInfo.TargetId)
}
inline std::string* RuleBaseCompareInfo::mutable_targetid() {
  std::string* _s = _internal_mutable_targetid();
  // @@protoc_insertion_point(field_mutable:protomsg.RuleBaseCompareInfo.TargetId)
  return _s;
}
inline const std::string& RuleBaseCompareInfo::_internal_targetid() const {
  return targetid_.Get();
}
inline void RuleBaseCompareInfo::_internal_set_targetid(const std::string& value) {
  
  targetid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* RuleBaseCompareInfo::_internal_mutable_targetid() {
  
  return targetid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* RuleBaseCompareInfo::release_targetid() {
  // @@protoc_insertion_point(field_release:protomsg.RuleBaseCompareInfo.TargetId)
  return targetid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void RuleBaseCompareInfo::set_allocated_targetid(std::string* targetid) {
  if (targetid != nullptr) {
    
  } else {
    
  }
  targetid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), targetid,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:protomsg.RuleBaseCompareInfo.TargetId)
}

// string TargetName = 6;
inline void RuleBaseCompareInfo::clear_targetname() {
  targetname_.ClearToEmpty();
}
inline const std::string& RuleBaseCompareInfo::targetname() const {
  // @@protoc_insertion_point(field_get:protomsg.RuleBaseCompareInfo.TargetName)
  return _internal_targetname();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RuleBaseCompareInfo::set_targetname(ArgT0&& arg0, ArgT... args) {
 
 targetname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:protomsg.RuleBaseCompareInfo.TargetName)
}
inline std::string* RuleBaseCompareInfo::mutable_targetname() {
  std::string* _s = _internal_mutable_targetname();
  // @@protoc_insertion_point(field_mutable:protomsg.RuleBaseCompareInfo.TargetName)
  return _s;
}
inline const std::string& RuleBaseCompareInfo::_internal_targetname() const {
  return targetname_.Get();
}
inline void RuleBaseCompareInfo::_internal_set_targetname(const std::string& value) {
  
  targetname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* RuleBaseCompareInfo::_internal_mutable_targetname() {
  
  return targetname_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* RuleBaseCompareInfo::release_targetname() {
  // @@protoc_insertion_point(field_release:protomsg.RuleBaseCompareInfo.TargetName)
  return targetname_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void RuleBaseCompareInfo::set_allocated_targetname(std::string* targetname) {
  if (targetname != nullptr) {
    
  } else {
    
  }
  targetname_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), targetname,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:protomsg.RuleBaseCompareInfo.TargetName)
}

// string TargetPicUrl = 7;
inline void RuleBaseCompareInfo::clear_targetpicurl() {
  targetpicurl_.ClearToEmpty();
}
inline const std::string& RuleBaseCompareInfo::targetpicurl() const {
  // @@protoc_insertion_point(field_get:protomsg.RuleBaseCompareInfo.TargetPicUrl)
  return _internal_targetpicurl();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RuleBaseCompareInfo::set_targetpicurl(ArgT0&& arg0, ArgT... args) {
 
 targetpicurl_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:protomsg.RuleBaseCompareInfo.TargetPicUrl)
}
inline std::string* RuleBaseCompareInfo::mutable_targetpicurl() {
  std::string* _s = _internal_mutable_targetpicurl();
  // @@protoc_insertion_point(field_mutable:protomsg.RuleBaseCompareInfo.TargetPicUrl)
  return _s;
}
inline const std::string& RuleBaseCompareInfo::_internal_targetpicurl() const {
  return targetpicurl_.Get();
}
inline void RuleBaseCompareInfo::_internal_set_targetpicurl(const std::string& value) {
  
  targetpicurl_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* RuleBaseCompareInfo::_internal_mutable_targetpicurl() {
  
  return targetpicurl_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* RuleBaseCompareInfo::release_targetpicurl() {
  // @@protoc_insertion_point(field_release:protomsg.RuleBaseCompareInfo.TargetPicUrl)
  return targetpicurl_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void RuleBaseCompareInfo::set_allocated_targetpicurl(std::string* targetpicurl) {
  if (targetpicurl != nullptr) {
    
  } else {
    
  }
  targetpicurl_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), targetpicurl,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:protomsg.RuleBaseCompareInfo.TargetPicUrl)
}

// string MonitorLevel = 8;
inline void RuleBaseCompareInfo::clear_monitorlevel() {
  monitorlevel_.ClearToEmpty();
}
inline const std::string& RuleBaseCompareInfo::monitorlevel() const {
  // @@protoc_insertion_point(field_get:protomsg.RuleBaseCompareInfo.MonitorLevel)
  return _internal_monitorlevel();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RuleBaseCompareInfo::set_monitorlevel(ArgT0&& arg0, ArgT... args) {
 
 monitorlevel_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:protomsg.RuleBaseCompareInfo.MonitorLevel)
}
inline std::string* RuleBaseCompareInfo::mutable_monitorlevel() {
  std::string* _s = _internal_mutable_monitorlevel();
  // @@protoc_insertion_point(field_mutable:protomsg.RuleBaseCompareInfo.MonitorLevel)
  return _s;
}
inline const std::string& RuleBaseCompareInfo::_internal_monitorlevel() const {
  return monitorlevel_.Get();
}
inline void RuleBaseCompareInfo::_internal_set_monitorlevel(const std::string& value) {
  
  monitorlevel_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* RuleBaseCompareInfo::_internal_mutable_monitorlevel() {
  
  return monitorlevel_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* RuleBaseCompareInfo::release_monitorlevel() {
  // @@protoc_insertion_point(field_release:protomsg.RuleBaseCompareInfo.MonitorLevel)
  return monitorlevel_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void RuleBaseCompareInfo::set_allocated_monitorlevel(std::string* monitorlevel) {
  if (monitorlevel != nullptr) {
    
  } else {
    
  }
  monitorlevel_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), monitorlevel,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:protomsg.RuleBaseCompareInfo.MonitorLevel)
}

// string Content = 9;
inline void RuleBaseCompareInfo::clear_content() {
  content_.ClearToEmpty();
}
inline const std::string& RuleBaseCompareInfo::content() const {
  // @@protoc_insertion_point(field_get:protomsg.RuleBaseCompareInfo.Content)
  return _internal_content();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RuleBaseCompareInfo::set_content(ArgT0&& arg0, ArgT... args) {
 
 content_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:protomsg.RuleBaseCompareInfo.Content)
}
inline std::string* RuleBaseCompareInfo::mutable_content() {
  std::string* _s = _internal_mutable_content();
  // @@protoc_insertion_point(field_mutable:protomsg.RuleBaseCompareInfo.Content)
  return _s;
}
inline const std::string& RuleBaseCompareInfo::_internal_content() const {
  return content_.Get();
}
inline void RuleBaseCompareInfo::_internal_set_content(const std::string& value) {
  
  content_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* RuleBaseCompareInfo::_internal_mutable_content() {
  
  return content_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* RuleBaseCompareInfo::release_content() {
  // @@protoc_insertion_point(field_release:protomsg.RuleBaseCompareInfo.Content)
  return content_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void RuleBaseCompareInfo::set_allocated_content(std::string* content) {
  if (content != nullptr) {
    
  } else {
    
  }
  content_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), content,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:protomsg.RuleBaseCompareInfo.Content)
}

// string DbLabel = 10;
inline void RuleBaseCompareInfo::clear_dblabel() {
  dblabel_.ClearToEmpty();
}
inline const std::string& RuleBaseCompareInfo::dblabel() const {
  // @@protoc_insertion_point(field_get:protomsg.RuleBaseCompareInfo.DbLabel)
  return _internal_dblabel();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RuleBaseCompareInfo::set_dblabel(ArgT0&& arg0, ArgT... args) {
 
 dblabel_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:protomsg.RuleBaseCompareInfo.DbLabel)
}
inline std::string* RuleBaseCompareInfo::mutable_dblabel() {
  std::string* _s = _internal_mutable_dblabel();
  // @@protoc_insertion_point(field_mutable:protomsg.RuleBaseCompareInfo.DbLabel)
  return _s;
}
inline const std::string& RuleBaseCompareInfo::_internal_dblabel() const {
  return dblabel_.Get();
}
inline void RuleBaseCompareInfo::_internal_set_dblabel(const std::string& value) {
  
  dblabel_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* RuleBaseCompareInfo::_internal_mutable_dblabel() {
  
  return dblabel_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* RuleBaseCompareInfo::release_dblabel() {
  // @@protoc_insertion_point(field_release:protomsg.RuleBaseCompareInfo.DbLabel)
  return dblabel_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void RuleBaseCompareInfo::set_allocated_dblabel(std::string* dblabel) {
  if (dblabel != nullptr) {
    
  } else {
    
  }
  dblabel_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), dblabel,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:protomsg.RuleBaseCompareInfo.DbLabel)
}

#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_rule_2eproto