opmon_entry.pb.h

Go to the documentation of this file.

// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: opmonlib/opmon_entry.proto
 
#ifndef GOOGLE_PROTOBUF_INCLUDED_opmonlib_2fopmon_5fentry_2eproto_2epb_2eh
#define GOOGLE_PROTOBUF_INCLUDED_opmonlib_2fopmon_5fentry_2eproto_2epb_2eh
 
#include <limits>
#include <string>
#include <type_traits>
 
#include "google/protobuf/port_def.inc"
#if PROTOBUF_VERSION < 4024000
#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  // PROTOBUF_VERSION
 
#if 4024004 < 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  // PROTOBUF_MIN_PROTOC_VERSION
#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_tctable_decl.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/map.h"  // IWYU pragma: export
#include "google/protobuf/map_entry.h"
#include "google/protobuf/map_field_inl.h"
#include "google/protobuf/generated_enum_reflection.h"
#include "google/protobuf/unknown_field_set.h"
#include "google/protobuf/timestamp.pb.h"
// @@protoc_insertion_point(includes)
 
// Must be included last.
#include "google/protobuf/port_def.inc"
 
#define PROTOBUF_INTERNAL_EXPORT_opmonlib_2fopmon_5fentry_2eproto
 
namespace google {
namespace protobuf {
namespace internal {
class AnyMetadata;
}  // namespace internal
}  // namespace protobuf
}  // namespace google
 
// Internal implementation detail -- do not use these members.
struct TableStruct_opmonlib_2fopmon_5fentry_2eproto {
  static const ::uint32_t offsets[];
};
extern const ::google::protobuf::internal::DescriptorTable
    descriptor_table_opmonlib_2fopmon_5fentry_2eproto;
namespace dunedaq {
namespace opmon {
class OpMonEntry;
struct OpMonEntryDefaultTypeInternal;
extern OpMonEntryDefaultTypeInternal _OpMonEntry_default_instance_;
class OpMonEntry_CustomOriginEntry_DoNotUse;
struct OpMonEntry_CustomOriginEntry_DoNotUseDefaultTypeInternal;
extern OpMonEntry_CustomOriginEntry_DoNotUseDefaultTypeInternal _OpMonEntry_CustomOriginEntry_DoNotUse_default_instance_;
class OpMonEntry_DataEntry_DoNotUse;
struct OpMonEntry_DataEntry_DoNotUseDefaultTypeInternal;
extern OpMonEntry_DataEntry_DoNotUseDefaultTypeInternal _OpMonEntry_DataEntry_DoNotUse_default_instance_;
class OpMonId;
struct OpMonIdDefaultTypeInternal;
extern OpMonIdDefaultTypeInternal _OpMonId_default_instance_;
class OpMonValue;
struct OpMonValueDefaultTypeInternal;
extern OpMonValueDefaultTypeInternal _OpMonValue_default_instance_;
}  // namespace opmon
}  // namespace dunedaq
namespace google {
namespace protobuf {
}  // namespace protobuf
}  // namespace google
 
namespace dunedaq {
namespace opmon {
enum NullValue : int {
  NULL_VALUE = 0,
  NullValue_INT_MIN_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::min(),
  NullValue_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};
 
bool NullValue_IsValid(int value);
constexpr NullValue NullValue_MIN = static_cast<NullValue>(0);
constexpr NullValue NullValue_MAX = static_cast<NullValue>(0);
constexpr int NullValue_ARRAYSIZE = 0 + 1;
const ::google::protobuf::EnumDescriptor*
NullValue_descriptor();
template <typename T>
const std::string& NullValue_Name(T value) {
  static_assert(std::is_same<T, NullValue>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to NullValue_Name().");
  return NullValue_Name(static_cast<NullValue>(value));
}
template <>
inline const std::string& NullValue_Name(NullValue value) {
  return ::google::protobuf::internal::NameOfDenseEnum<NullValue_descriptor,
                                                 0, 0>(
      static_cast<int>(value));
}
inline bool NullValue_Parse(absl::string_view name, NullValue* value) {
  return ::google::protobuf::internal::ParseNamedEnum<NullValue>(
      NullValue_descriptor(), name, value);
}
 
// ===================================================================
 
 
// -------------------------------------------------------------------
 
class OpMonValue final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dunedaq.opmon.OpMonValue) */ {
 public:
  inline OpMonValue() : OpMonValue(nullptr) {}
  ~OpMonValue() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR OpMonValue(::google::protobuf::internal::ConstantInitialized);
 
  OpMonValue(const OpMonValue& from);
  OpMonValue(OpMonValue&& from) noexcept
    : OpMonValue() {
    *this = ::std::move(from);
  }
 
  inline OpMonValue& operator=(const OpMonValue& from) {
    CopyFrom(from);
    return *this;
  }
  inline OpMonValue& operator=(OpMonValue&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
 
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }
 
  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const OpMonValue& default_instance() {
    return *internal_default_instance();
  }
  enum KindCase {
    kNullValue = 1,
    kInt4Value = 2,
    kInt8Value = 3,
    kUint4Value = 4,
    kUint8Value = 5,
    kDoubleValue = 10,
    kFloatValue = 11,
    kBooleanValue = 15,
    kStringValue = 20,
    KIND_NOT_SET = 0,
  };
 
  static inline const OpMonValue* internal_default_instance() {
    return reinterpret_cast<const OpMonValue*>(
               &_OpMonValue_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;
 
  friend void swap(OpMonValue& a, OpMonValue& b) {
    a.Swap(&b);
  }
  inline void Swap(OpMonValue* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(OpMonValue* other) {
    if (other == this) return;
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  OpMonValue* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<OpMonValue>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const OpMonValue& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const OpMonValue& from) {
    OpMonValue::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;
 
  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
 
  private:
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(OpMonValue* other);
 
  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "dunedaq.opmon.OpMonValue";
  }
  protected:
  explicit OpMonValue(::google::protobuf::Arena* arena);
  public:
 
  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;
 
  ::google::protobuf::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  enum : int {
    kNullValueFieldNumber = 1,
    kInt4ValueFieldNumber = 2,
    kInt8ValueFieldNumber = 3,
    kUint4ValueFieldNumber = 4,
    kUint8ValueFieldNumber = 5,
    kDoubleValueFieldNumber = 10,
    kFloatValueFieldNumber = 11,
    kBooleanValueFieldNumber = 15,
    kStringValueFieldNumber = 20,
  };
  // .dunedaq.opmon.NullValue null_value = 1;
  bool has_null_value() const;
  void clear_null_value() ;
  ::dunedaq::opmon::NullValue null_value() const;
  void set_null_value(::dunedaq::opmon::NullValue value);
 
  private:
  ::dunedaq::opmon::NullValue _internal_null_value() const;
  void _internal_set_null_value(::dunedaq::opmon::NullValue value);
 
  public:
  // int32 int4_value = 2;
  bool has_int4_value() const;
  void clear_int4_value() ;
  ::int32_t int4_value() const;
  void set_int4_value(::int32_t value);
 
  private:
  ::int32_t _internal_int4_value() const;
  void _internal_set_int4_value(::int32_t value);
 
  public:
  // int64 int8_value = 3;
  bool has_int8_value() const;
  void clear_int8_value() ;
  ::int64_t int8_value() const;
  void set_int8_value(::int64_t value);
 
  private:
  ::int64_t _internal_int8_value() const;
  void _internal_set_int8_value(::int64_t value);
 
  public:
  // uint32 uint4_value = 4;
  bool has_uint4_value() const;
  void clear_uint4_value() ;
  ::uint32_t uint4_value() const;
  void set_uint4_value(::uint32_t value);
 
  private:
  ::uint32_t _internal_uint4_value() const;
  void _internal_set_uint4_value(::uint32_t value);
 
  public:
  // uint64 uint8_value = 5;
  bool has_uint8_value() const;
  void clear_uint8_value() ;
  ::uint64_t uint8_value() const;
  void set_uint8_value(::uint64_t value);
 
  private:
  ::uint64_t _internal_uint8_value() const;
  void _internal_set_uint8_value(::uint64_t value);
 
  public:
  // double double_value = 10;
  bool has_double_value() const;
  void clear_double_value() ;
  double double_value() const;
  void set_double_value(double value);
 
  private:
  double _internal_double_value() const;
  void _internal_set_double_value(double value);
 
  public:
  // float float_value = 11;
  bool has_float_value() const;
  void clear_float_value() ;
  float float_value() const;
  void set_float_value(float value);
 
  private:
  float _internal_float_value() const;
  void _internal_set_float_value(float value);
 
  public:
  // bool boolean_value = 15;
  bool has_boolean_value() const;
  void clear_boolean_value() ;
  bool boolean_value() const;
  void set_boolean_value(bool value);
 
  private:
  bool _internal_boolean_value() const;
  void _internal_set_boolean_value(bool value);
 
  public:
  // string string_value = 20;
  bool has_string_value() const;
  void clear_string_value() ;
  const std::string& string_value() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_string_value(Arg_&& arg, Args_... args);
  std::string* mutable_string_value();
  PROTOBUF_NODISCARD std::string* release_string_value();
  void set_allocated_string_value(std::string* ptr);
 
  private:
  const std::string& _internal_string_value() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_string_value(
      const std::string& value);
  std::string* _internal_mutable_string_value();
 
  public:
  void clear_kind();
  KindCase kind_case() const;
  // @@protoc_insertion_point(class_scope:dunedaq.opmon.OpMonValue)
 private:
  class _Internal;
  void set_has_null_value();
  void set_has_int4_value();
  void set_has_int8_value();
  void set_has_uint4_value();
  void set_has_uint8_value();
  void set_has_double_value();
  void set_has_float_value();
  void set_has_boolean_value();
  void set_has_string_value();
 
  inline bool has_kind() const;
  inline void clear_has_kind();
 
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<0, 9, 0, 53, 2> _table_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    union KindUnion {
      constexpr KindUnion() : _constinit_{} {}
        ::google::protobuf::internal::ConstantInitialized _constinit_;
      int null_value_;
      ::int32_t int4_value_;
      ::int64_t int8_value_;
      ::uint32_t uint4_value_;
      ::uint64_t uint8_value_;
      double double_value_;
      float float_value_;
      bool boolean_value_;
      ::google::protobuf::internal::ArenaStringPtr string_value_;
    } kind_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::uint32_t _oneof_case_[1];
 
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_opmonlib_2fopmon_5fentry_2eproto;
};// -------------------------------------------------------------------
 
class OpMonId final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dunedaq.opmon.OpMonId) */ {
 public:
  inline OpMonId() : OpMonId(nullptr) {}
  ~OpMonId() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR OpMonId(::google::protobuf::internal::ConstantInitialized);
 
  OpMonId(const OpMonId& from);
  OpMonId(OpMonId&& from) noexcept
    : OpMonId() {
    *this = ::std::move(from);
  }
 
  inline OpMonId& operator=(const OpMonId& from) {
    CopyFrom(from);
    return *this;
  }
  inline OpMonId& operator=(OpMonId&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
 
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }
 
  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const OpMonId& default_instance() {
    return *internal_default_instance();
  }
  static inline const OpMonId* internal_default_instance() {
    return reinterpret_cast<const OpMonId*>(
               &_OpMonId_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;
 
  friend void swap(OpMonId& a, OpMonId& b) {
    a.Swap(&b);
  }
  inline void Swap(OpMonId* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(OpMonId* other) {
    if (other == this) return;
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  OpMonId* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<OpMonId>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const OpMonId& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const OpMonId& from) {
    OpMonId::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;
 
  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
 
  private:
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(OpMonId* other);
 
  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "dunedaq.opmon.OpMonId";
  }
  protected:
  explicit OpMonId(::google::protobuf::Arena* arena);
  public:
 
  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;
 
  ::google::protobuf::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  enum : int {
    kSubstructureFieldNumber = 10,
    kSessionFieldNumber = 1,
    kApplicationFieldNumber = 2,
  };
  // repeated string substructure = 10;
  int substructure_size() const;
  private:
  int _internal_substructure_size() const;
 
  public:
  void clear_substructure() ;
  const std::string& substructure(int index) const;
  std::string* mutable_substructure(int index);
  void set_substructure(int index, const std::string& value);
  void set_substructure(int index, std::string&& value);
  void set_substructure(int index, const char* value);
  void set_substructure(int index, const char* value, std::size_t size);
  void set_substructure(int index, absl::string_view value);
  std::string* add_substructure();
  void add_substructure(const std::string& value);
  void add_substructure(std::string&& value);
  void add_substructure(const char* value);
  void add_substructure(const char* value, std::size_t size);
  void add_substructure(absl::string_view value);
  const ::google::protobuf::RepeatedPtrField<std::string>& substructure() const;
  ::google::protobuf::RepeatedPtrField<std::string>* mutable_substructure();
 
  private:
  const ::google::protobuf::RepeatedPtrField<std::string>& _internal_substructure() const;
  ::google::protobuf::RepeatedPtrField<std::string>* _internal_mutable_substructure();
 
  public:
  // string session = 1;
  void clear_session() ;
  const std::string& session() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_session(Arg_&& arg, Args_... args);
  std::string* mutable_session();
  PROTOBUF_NODISCARD std::string* release_session();
  void set_allocated_session(std::string* ptr);
 
  private:
  const std::string& _internal_session() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_session(
      const std::string& value);
  std::string* _internal_mutable_session();
 
  public:
  // string application = 2;
  void clear_application() ;
  const std::string& application() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_application(Arg_&& arg, Args_... args);
  std::string* mutable_application();
  PROTOBUF_NODISCARD std::string* release_application();
  void set_allocated_application(std::string* ptr);
 
  private:
  const std::string& _internal_application() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_application(
      const std::string& value);
  std::string* _internal_mutable_application();
 
  public:
  // @@protoc_insertion_point(class_scope:dunedaq.opmon.OpMonId)
 private:
  class _Internal;
 
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<1, 3, 0, 60, 2> _table_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::google::protobuf::RepeatedPtrField<std::string> substructure_;
    ::google::protobuf::internal::ArenaStringPtr session_;
    ::google::protobuf::internal::ArenaStringPtr application_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_opmonlib_2fopmon_5fentry_2eproto;
};// -------------------------------------------------------------------
 
class OpMonEntry_CustomOriginEntry_DoNotUse final : public ::google::protobuf::internal::MapEntry<OpMonEntry_CustomOriginEntry_DoNotUse, 
    std::string, std::string,
    ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
    ::google::protobuf::internal::WireFormatLite::TYPE_STRING> {
public:
  typedef ::google::protobuf::internal::MapEntry<OpMonEntry_CustomOriginEntry_DoNotUse, 
    std::string, std::string,
    ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
    ::google::protobuf::internal::WireFormatLite::TYPE_STRING> SuperType;
  OpMonEntry_CustomOriginEntry_DoNotUse();
  template <typename = void>
  explicit PROTOBUF_CONSTEXPR OpMonEntry_CustomOriginEntry_DoNotUse(
      ::google::protobuf::internal::ConstantInitialized);
  explicit OpMonEntry_CustomOriginEntry_DoNotUse(::google::protobuf::Arena* arena);
  void MergeFrom(const OpMonEntry_CustomOriginEntry_DoNotUse& other);
  static const OpMonEntry_CustomOriginEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const OpMonEntry_CustomOriginEntry_DoNotUse*>(&_OpMonEntry_CustomOriginEntry_DoNotUse_default_instance_); }
  static bool ValidateKey(std::string* s) {
    return ::google::protobuf::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::google::protobuf::internal::WireFormatLite::PARSE, "dunedaq.opmon.OpMonEntry.CustomOriginEntry.key");
 }
  static bool ValidateValue(std::string* s) {
    return ::google::protobuf::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::google::protobuf::internal::WireFormatLite::PARSE, "dunedaq.opmon.OpMonEntry.CustomOriginEntry.value");
 }
  using ::google::protobuf::Message::MergeFrom;
  ::google::protobuf::Metadata GetMetadata() const final;
  friend struct ::TableStruct_opmonlib_2fopmon_5fentry_2eproto;
};
// -------------------------------------------------------------------
 
class OpMonEntry_DataEntry_DoNotUse final : public ::google::protobuf::internal::MapEntry<OpMonEntry_DataEntry_DoNotUse, 
    std::string, ::dunedaq::opmon::OpMonValue,
    ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
    ::google::protobuf::internal::WireFormatLite::TYPE_MESSAGE> {
public:
  typedef ::google::protobuf::internal::MapEntry<OpMonEntry_DataEntry_DoNotUse, 
    std::string, ::dunedaq::opmon::OpMonValue,
    ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
    ::google::protobuf::internal::WireFormatLite::TYPE_MESSAGE> SuperType;
  OpMonEntry_DataEntry_DoNotUse();
  template <typename = void>
  explicit PROTOBUF_CONSTEXPR OpMonEntry_DataEntry_DoNotUse(
      ::google::protobuf::internal::ConstantInitialized);
  explicit OpMonEntry_DataEntry_DoNotUse(::google::protobuf::Arena* arena);
  void MergeFrom(const OpMonEntry_DataEntry_DoNotUse& other);
  static const OpMonEntry_DataEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const OpMonEntry_DataEntry_DoNotUse*>(&_OpMonEntry_DataEntry_DoNotUse_default_instance_); }
  static bool ValidateKey(std::string* s) {
    return ::google::protobuf::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::google::protobuf::internal::WireFormatLite::PARSE, "dunedaq.opmon.OpMonEntry.DataEntry.key");
 }
  static bool ValidateValue(void*) { return true; }
  using ::google::protobuf::Message::MergeFrom;
  ::google::protobuf::Metadata GetMetadata() const final;
  friend struct ::TableStruct_opmonlib_2fopmon_5fentry_2eproto;
};
// -------------------------------------------------------------------
 
class OpMonEntry final :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dunedaq.opmon.OpMonEntry) */ {
 public:
  inline OpMonEntry() : OpMonEntry(nullptr) {}
  ~OpMonEntry() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR OpMonEntry(::google::protobuf::internal::ConstantInitialized);
 
  OpMonEntry(const OpMonEntry& from);
  OpMonEntry(OpMonEntry&& from) noexcept
    : OpMonEntry() {
    *this = ::std::move(from);
  }
 
  inline OpMonEntry& operator=(const OpMonEntry& from) {
    CopyFrom(from);
    return *this;
  }
  inline OpMonEntry& operator=(OpMonEntry&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
 
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }
 
  static const ::google::protobuf::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const OpMonEntry& default_instance() {
    return *internal_default_instance();
  }
  static inline const OpMonEntry* internal_default_instance() {
    return reinterpret_cast<const OpMonEntry*>(
               &_OpMonEntry_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;
 
  friend void swap(OpMonEntry& a, OpMonEntry& b) {
    a.Swap(&b);
  }
  inline void Swap(OpMonEntry* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(OpMonEntry* other) {
    if (other == this) return;
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  OpMonEntry* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<OpMonEntry>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const OpMonEntry& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom( const OpMonEntry& from) {
    OpMonEntry::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;
 
  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
 
  private:
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(OpMonEntry* other);
 
  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "dunedaq.opmon.OpMonEntry";
  }
  protected:
  explicit OpMonEntry(::google::protobuf::Arena* arena);
  public:
 
  static const ClassData _class_data_;
  const ::google::protobuf::Message::ClassData*GetClassData() const final;
 
  ::google::protobuf::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
 
  // accessors -------------------------------------------------------
 
  enum : int {
    kCustomOriginFieldNumber = 3,
    kDataFieldNumber = 10,
    kMeasurementFieldNumber = 5,
    kTimeFieldNumber = 1,
    kOriginFieldNumber = 2,
  };
  // map<string, string> custom_origin = 3;
  int custom_origin_size() const;
  private:
  int _internal_custom_origin_size() const;
 
  public:
  void clear_custom_origin() ;
  const ::google::protobuf::Map<std::string, std::string>& custom_origin() const;
  ::google::protobuf::Map<std::string, std::string>* mutable_custom_origin();
 
  private:
  const ::google::protobuf::Map<std::string, std::string>& _internal_custom_origin() const;
  ::google::protobuf::Map<std::string, std::string>* _internal_mutable_custom_origin();
 
  public:
  // map<string, .dunedaq.opmon.OpMonValue> data = 10;
  int data_size() const;
  private:
  int _internal_data_size() const;
 
  public:
  void clear_data() ;
  const ::google::protobuf::Map<std::string, ::dunedaq::opmon::OpMonValue>& data() const;
  ::google::protobuf::Map<std::string, ::dunedaq::opmon::OpMonValue>* mutable_data();
 
  private:
  const ::google::protobuf::Map<std::string, ::dunedaq::opmon::OpMonValue>& _internal_data() const;
  ::google::protobuf::Map<std::string, ::dunedaq::opmon::OpMonValue>* _internal_mutable_data();
 
  public:
  // string measurement = 5;
  void clear_measurement() ;
  const std::string& measurement() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_measurement(Arg_&& arg, Args_... args);
  std::string* mutable_measurement();
  PROTOBUF_NODISCARD std::string* release_measurement();
  void set_allocated_measurement(std::string* ptr);
 
  private:
  const std::string& _internal_measurement() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_measurement(
      const std::string& value);
  std::string* _internal_mutable_measurement();
 
  public:
  // .google.protobuf.Timestamp time = 1;
  bool has_time() const;
  void clear_time() ;
  const ::google::protobuf::Timestamp& time() const;
  PROTOBUF_NODISCARD ::google::protobuf::Timestamp* release_time();
  ::google::protobuf::Timestamp* mutable_time();
  void set_allocated_time(::google::protobuf::Timestamp* value);
  void unsafe_arena_set_allocated_time(::google::protobuf::Timestamp* value);
  ::google::protobuf::Timestamp* unsafe_arena_release_time();
 
  private:
  const ::google::protobuf::Timestamp& _internal_time() const;
  ::google::protobuf::Timestamp* _internal_mutable_time();
 
  public:
  // .dunedaq.opmon.OpMonId origin = 2;
  bool has_origin() const;
  void clear_origin() ;
  const ::dunedaq::opmon::OpMonId& origin() const;
  PROTOBUF_NODISCARD ::dunedaq::opmon::OpMonId* release_origin();
  ::dunedaq::opmon::OpMonId* mutable_origin();
  void set_allocated_origin(::dunedaq::opmon::OpMonId* value);
  void unsafe_arena_set_allocated_origin(::dunedaq::opmon::OpMonId* value);
  ::dunedaq::opmon::OpMonId* unsafe_arena_release_origin();
 
  private:
  const ::dunedaq::opmon::OpMonId& _internal_origin() const;
  ::dunedaq::opmon::OpMonId* _internal_mutable_origin();
 
  public:
  // @@protoc_insertion_point(class_scope:dunedaq.opmon.OpMonEntry)
 private:
  class _Internal;
 
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<3, 5, 5, 61, 2> _table_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::internal::MapField<OpMonEntry_CustomOriginEntry_DoNotUse, std::string, std::string,
                      ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
                      ::google::protobuf::internal::WireFormatLite::TYPE_STRING>
        custom_origin_;
    ::google::protobuf::internal::MapField<OpMonEntry_DataEntry_DoNotUse, std::string, ::dunedaq::opmon::OpMonValue,
                      ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
                      ::google::protobuf::internal::WireFormatLite::TYPE_MESSAGE>
        data_;
    ::google::protobuf::internal::ArenaStringPtr measurement_;
    ::google::protobuf::Timestamp* time_;
    ::dunedaq::opmon::OpMonId* origin_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_opmonlib_2fopmon_5fentry_2eproto;
};
 
// ===================================================================
 
 
 
 
// ===================================================================
 
 
#ifdef __GNUC__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif  // __GNUC__
// -------------------------------------------------------------------
 
// OpMonValue
 
// .dunedaq.opmon.NullValue null_value = 1;
inline bool OpMonValue::has_null_value() const {
  return kind_case() == kNullValue;
}
inline void OpMonValue::set_has_null_value() {
  _impl_._oneof_case_[0] = kNullValue;
}
inline void OpMonValue::clear_null_value() {
  if (kind_case() == kNullValue) {
    _impl_.kind_.null_value_ = 0;
    clear_has_kind();
  }
}
inline ::dunedaq::opmon::NullValue OpMonValue::null_value() const {
  // @@protoc_insertion_point(field_get:dunedaq.opmon.OpMonValue.null_value)
  return _internal_null_value();
}
inline void OpMonValue::set_null_value(::dunedaq::opmon::NullValue value) {
  _internal_set_null_value(value);
  // @@protoc_insertion_point(field_set:dunedaq.opmon.OpMonValue.null_value)
}
inline ::dunedaq::opmon::NullValue OpMonValue::_internal_null_value() const {
  if (kind_case() == kNullValue) {
    return static_cast<::dunedaq::opmon::NullValue>(_impl_.kind_.null_value_);
  }
  return static_cast<::dunedaq::opmon::NullValue>(0);
}
inline void OpMonValue::_internal_set_null_value(::dunedaq::opmon::NullValue value) {
  if (kind_case() != kNullValue) {
    clear_kind();
    set_has_null_value();
  }
  _impl_.kind_.null_value_ = value;
}
 
// int32 int4_value = 2;
inline bool OpMonValue::has_int4_value() const {
  return kind_case() == kInt4Value;
}
inline void OpMonValue::set_has_int4_value() {
  _impl_._oneof_case_[0] = kInt4Value;
}
inline void OpMonValue::clear_int4_value() {
  if (kind_case() == kInt4Value) {
    _impl_.kind_.int4_value_ = 0;
    clear_has_kind();
  }
}
inline ::int32_t OpMonValue::int4_value() const {
  // @@protoc_insertion_point(field_get:dunedaq.opmon.OpMonValue.int4_value)
  return _internal_int4_value();
}
inline void OpMonValue::set_int4_value(::int32_t value) {
  _internal_set_int4_value(value);
  // @@protoc_insertion_point(field_set:dunedaq.opmon.OpMonValue.int4_value)
}
inline ::int32_t OpMonValue::_internal_int4_value() const {
  if (kind_case() == kInt4Value) {
    return _impl_.kind_.int4_value_;
  }
  return 0;
}
inline void OpMonValue::_internal_set_int4_value(::int32_t value) {
  if (kind_case() != kInt4Value) {
    clear_kind();
    set_has_int4_value();
  }
  _impl_.kind_.int4_value_ = value;
}
 
// int64 int8_value = 3;
inline bool OpMonValue::has_int8_value() const {
  return kind_case() == kInt8Value;
}
inline void OpMonValue::set_has_int8_value() {
  _impl_._oneof_case_[0] = kInt8Value;
}
inline void OpMonValue::clear_int8_value() {
  if (kind_case() == kInt8Value) {
    _impl_.kind_.int8_value_ = ::int64_t{0};
    clear_has_kind();
  }
}
inline ::int64_t OpMonValue::int8_value() const {
  // @@protoc_insertion_point(field_get:dunedaq.opmon.OpMonValue.int8_value)
  return _internal_int8_value();
}
inline void OpMonValue::set_int8_value(::int64_t value) {
  _internal_set_int8_value(value);
  // @@protoc_insertion_point(field_set:dunedaq.opmon.OpMonValue.int8_value)
}
inline ::int64_t OpMonValue::_internal_int8_value() const {
  if (kind_case() == kInt8Value) {
    return _impl_.kind_.int8_value_;
  }
  return ::int64_t{0};
}
inline void OpMonValue::_internal_set_int8_value(::int64_t value) {
  if (kind_case() != kInt8Value) {
    clear_kind();
    set_has_int8_value();
  }
  _impl_.kind_.int8_value_ = value;
}
 
// uint32 uint4_value = 4;
inline bool OpMonValue::has_uint4_value() const {
  return kind_case() == kUint4Value;
}
inline void OpMonValue::set_has_uint4_value() {
  _impl_._oneof_case_[0] = kUint4Value;
}
inline void OpMonValue::clear_uint4_value() {
  if (kind_case() == kUint4Value) {
    _impl_.kind_.uint4_value_ = 0u;
    clear_has_kind();
  }
}
inline ::uint32_t OpMonValue::uint4_value() const {
  // @@protoc_insertion_point(field_get:dunedaq.opmon.OpMonValue.uint4_value)
  return _internal_uint4_value();
}
inline void OpMonValue::set_uint4_value(::uint32_t value) {
  _internal_set_uint4_value(value);
  // @@protoc_insertion_point(field_set:dunedaq.opmon.OpMonValue.uint4_value)
}
inline ::uint32_t OpMonValue::_internal_uint4_value() const {
  if (kind_case() == kUint4Value) {
    return _impl_.kind_.uint4_value_;
  }
  return 0u;
}
inline void OpMonValue::_internal_set_uint4_value(::uint32_t value) {
  if (kind_case() != kUint4Value) {
    clear_kind();
    set_has_uint4_value();
  }
  _impl_.kind_.uint4_value_ = value;
}
 
// uint64 uint8_value = 5;
inline bool OpMonValue::has_uint8_value() const {
  return kind_case() == kUint8Value;
}
inline void OpMonValue::set_has_uint8_value() {
  _impl_._oneof_case_[0] = kUint8Value;
}
inline void OpMonValue::clear_uint8_value() {
  if (kind_case() == kUint8Value) {
    _impl_.kind_.uint8_value_ = ::uint64_t{0u};
    clear_has_kind();
  }
}
inline ::uint64_t OpMonValue::uint8_value() const {
  // @@protoc_insertion_point(field_get:dunedaq.opmon.OpMonValue.uint8_value)
  return _internal_uint8_value();
}
inline void OpMonValue::set_uint8_value(::uint64_t value) {
  _internal_set_uint8_value(value);
  // @@protoc_insertion_point(field_set:dunedaq.opmon.OpMonValue.uint8_value)
}
inline ::uint64_t OpMonValue::_internal_uint8_value() const {
  if (kind_case() == kUint8Value) {
    return _impl_.kind_.uint8_value_;
  }
  return ::uint64_t{0u};
}
inline void OpMonValue::_internal_set_uint8_value(::uint64_t value) {
  if (kind_case() != kUint8Value) {
    clear_kind();
    set_has_uint8_value();
  }
  _impl_.kind_.uint8_value_ = value;
}
 
// double double_value = 10;
inline bool OpMonValue::has_double_value() const {
  return kind_case() == kDoubleValue;
}
inline void OpMonValue::set_has_double_value() {
  _impl_._oneof_case_[0] = kDoubleValue;
}
inline void OpMonValue::clear_double_value() {
  if (kind_case() == kDoubleValue) {
    _impl_.kind_.double_value_ = 0;
    clear_has_kind();
  }
}
inline double OpMonValue::double_value() const {
  // @@protoc_insertion_point(field_get:dunedaq.opmon.OpMonValue.double_value)
  return _internal_double_value();
}
inline void OpMonValue::set_double_value(double value) {
  _internal_set_double_value(value);
  // @@protoc_insertion_point(field_set:dunedaq.opmon.OpMonValue.double_value)
}
inline double OpMonValue::_internal_double_value() const {
  if (kind_case() == kDoubleValue) {
    return _impl_.kind_.double_value_;
  }
  return 0;
}
inline void OpMonValue::_internal_set_double_value(double value) {
  if (kind_case() != kDoubleValue) {
    clear_kind();
    set_has_double_value();
  }
  _impl_.kind_.double_value_ = value;
}
 
// float float_value = 11;
inline bool OpMonValue::has_float_value() const {
  return kind_case() == kFloatValue;
}
inline void OpMonValue::set_has_float_value() {
  _impl_._oneof_case_[0] = kFloatValue;
}
inline void OpMonValue::clear_float_value() {
  if (kind_case() == kFloatValue) {
    _impl_.kind_.float_value_ = 0;
    clear_has_kind();
  }
}
inline float OpMonValue::float_value() const {
  // @@protoc_insertion_point(field_get:dunedaq.opmon.OpMonValue.float_value)
  return _internal_float_value();
}
inline void OpMonValue::set_float_value(float value) {
  _internal_set_float_value(value);
  // @@protoc_insertion_point(field_set:dunedaq.opmon.OpMonValue.float_value)
}
inline float OpMonValue::_internal_float_value() const {
  if (kind_case() == kFloatValue) {
    return _impl_.kind_.float_value_;
  }
  return 0;
}
inline void OpMonValue::_internal_set_float_value(float value) {
  if (kind_case() != kFloatValue) {
    clear_kind();
    set_has_float_value();
  }
  _impl_.kind_.float_value_ = value;
}
 
// bool boolean_value = 15;
inline bool OpMonValue::has_boolean_value() const {
  return kind_case() == kBooleanValue;
}
inline void OpMonValue::set_has_boolean_value() {
  _impl_._oneof_case_[0] = kBooleanValue;
}
inline void OpMonValue::clear_boolean_value() {
  if (kind_case() == kBooleanValue) {
    _impl_.kind_.boolean_value_ = false;
    clear_has_kind();
  }
}
inline bool OpMonValue::boolean_value() const {
  // @@protoc_insertion_point(field_get:dunedaq.opmon.OpMonValue.boolean_value)
  return _internal_boolean_value();
}
inline void OpMonValue::set_boolean_value(bool value) {
  _internal_set_boolean_value(value);
  // @@protoc_insertion_point(field_set:dunedaq.opmon.OpMonValue.boolean_value)
}
inline bool OpMonValue::_internal_boolean_value() const {
  if (kind_case() == kBooleanValue) {
    return _impl_.kind_.boolean_value_;
  }
  return false;
}
inline void OpMonValue::_internal_set_boolean_value(bool value) {
  if (kind_case() != kBooleanValue) {
    clear_kind();
    set_has_boolean_value();
  }
  _impl_.kind_.boolean_value_ = value;
}
 
// string string_value = 20;
inline bool OpMonValue::has_string_value() const {
  return kind_case() == kStringValue;
}
inline void OpMonValue::set_has_string_value() {
  _impl_._oneof_case_[0] = kStringValue;
}
inline void OpMonValue::clear_string_value() {
  if (kind_case() == kStringValue) {
    _impl_.kind_.string_value_.Destroy();
    clear_has_kind();
  }
}
inline const std::string& OpMonValue::string_value() const {
  // @@protoc_insertion_point(field_get:dunedaq.opmon.OpMonValue.string_value)
  return _internal_string_value();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void OpMonValue::set_string_value(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (kind_case() != kStringValue) {
    clear_kind();
 
    set_has_string_value();
    _impl_.kind_.string_value_.InitDefault();
  }
  _impl_.kind_.string_value_.Set(static_cast<Arg_&&>(arg), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:dunedaq.opmon.OpMonValue.string_value)
}
inline std::string* OpMonValue::mutable_string_value() {
  std::string* _s = _internal_mutable_string_value();
  // @@protoc_insertion_point(field_mutable:dunedaq.opmon.OpMonValue.string_value)
  return _s;
}
inline const std::string& OpMonValue::_internal_string_value() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  if (kind_case() != kStringValue) {
    return ::google::protobuf::internal::GetEmptyStringAlreadyInited();
  }
  return _impl_.kind_.string_value_.Get();
}
inline void OpMonValue::_internal_set_string_value(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (kind_case() != kStringValue) {
    clear_kind();
 
    set_has_string_value();
    _impl_.kind_.string_value_.InitDefault();
  }
  _impl_.kind_.string_value_.Set(value, GetArenaForAllocation());
}
inline std::string* OpMonValue::_internal_mutable_string_value() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (kind_case() != kStringValue) {
    clear_kind();
 
    set_has_string_value();
    _impl_.kind_.string_value_.InitDefault();
  }
  return _impl_.kind_.string_value_.Mutable( GetArenaForAllocation());
}
inline std::string* OpMonValue::release_string_value() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:dunedaq.opmon.OpMonValue.string_value)
  if (kind_case() != kStringValue) {
    return nullptr;
  }
  clear_has_kind();
  return _impl_.kind_.string_value_.Release();
}
inline void OpMonValue::set_allocated_string_value(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (has_kind()) {
    clear_kind();
  }
  if (value != nullptr) {
    set_has_string_value();
    _impl_.kind_.string_value_.InitAllocated(value, GetArenaForAllocation());
  }
  // @@protoc_insertion_point(field_set_allocated:dunedaq.opmon.OpMonValue.string_value)
}
 
inline bool OpMonValue::has_kind() const {
  return kind_case() != KIND_NOT_SET;
}
inline void OpMonValue::clear_has_kind() {
  _impl_._oneof_case_[0] = KIND_NOT_SET;
}
inline OpMonValue::KindCase OpMonValue::kind_case() const {
  return OpMonValue::KindCase(_impl_._oneof_case_[0]);
}
// -------------------------------------------------------------------
 
// OpMonId
 
// string session = 1;
inline void OpMonId::clear_session() {
  _impl_.session_.ClearToEmpty();
}
inline const std::string& OpMonId::session() const {
  // @@protoc_insertion_point(field_get:dunedaq.opmon.OpMonId.session)
  return _internal_session();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void OpMonId::set_session(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.session_.Set(static_cast<Arg_&&>(arg), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:dunedaq.opmon.OpMonId.session)
}
inline std::string* OpMonId::mutable_session() {
  std::string* _s = _internal_mutable_session();
  // @@protoc_insertion_point(field_mutable:dunedaq.opmon.OpMonId.session)
  return _s;
}
inline const std::string& OpMonId::_internal_session() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.session_.Get();
}
inline void OpMonId::_internal_set_session(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.session_.Set(value, GetArenaForAllocation());
}
inline std::string* OpMonId::_internal_mutable_session() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.session_.Mutable( GetArenaForAllocation());
}
inline std::string* OpMonId::release_session() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:dunedaq.opmon.OpMonId.session)
  return _impl_.session_.Release();
}
inline void OpMonId::set_allocated_session(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.session_.SetAllocated(value, GetArenaForAllocation());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.session_.IsDefault()) {
          _impl_.session_.Set("", GetArenaForAllocation());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:dunedaq.opmon.OpMonId.session)
}
 
// string application = 2;
inline void OpMonId::clear_application() {
  _impl_.application_.ClearToEmpty();
}
inline const std::string& OpMonId::application() const {
  // @@protoc_insertion_point(field_get:dunedaq.opmon.OpMonId.application)
  return _internal_application();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void OpMonId::set_application(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.application_.Set(static_cast<Arg_&&>(arg), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:dunedaq.opmon.OpMonId.application)
}
inline std::string* OpMonId::mutable_application() {
  std::string* _s = _internal_mutable_application();
  // @@protoc_insertion_point(field_mutable:dunedaq.opmon.OpMonId.application)
  return _s;
}
inline const std::string& OpMonId::_internal_application() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.application_.Get();
}
inline void OpMonId::_internal_set_application(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.application_.Set(value, GetArenaForAllocation());
}
inline std::string* OpMonId::_internal_mutable_application() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.application_.Mutable( GetArenaForAllocation());
}
inline std::string* OpMonId::release_application() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:dunedaq.opmon.OpMonId.application)
  return _impl_.application_.Release();
}
inline void OpMonId::set_allocated_application(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.application_.SetAllocated(value, GetArenaForAllocation());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.application_.IsDefault()) {
          _impl_.application_.Set("", GetArenaForAllocation());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:dunedaq.opmon.OpMonId.application)
}
 
// repeated string substructure = 10;
inline int OpMonId::_internal_substructure_size() const {
  return _internal_substructure().size();
}
inline int OpMonId::substructure_size() const {
  return _internal_substructure_size();
}
inline void OpMonId::clear_substructure() {
  _internal_mutable_substructure()->Clear();
}
inline std::string* OpMonId::add_substructure() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  std::string* _s = _internal_mutable_substructure()->Add();
  // @@protoc_insertion_point(field_add_mutable:dunedaq.opmon.OpMonId.substructure)
  return _s;
}
inline const std::string& OpMonId::substructure(int index) const {
  // @@protoc_insertion_point(field_get:dunedaq.opmon.OpMonId.substructure)
  return _internal_substructure().Get(index);
}
inline std::string* OpMonId::mutable_substructure(int index) {
  // @@protoc_insertion_point(field_mutable:dunedaq.opmon.OpMonId.substructure)
  return _internal_mutable_substructure()->Mutable(index);
}
inline void OpMonId::set_substructure(int index, const std::string& value) {
  _internal_mutable_substructure()->Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:dunedaq.opmon.OpMonId.substructure)
}
inline void OpMonId::set_substructure(int index, std::string&& value) {
  _internal_mutable_substructure()->Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:dunedaq.opmon.OpMonId.substructure)
}
inline void OpMonId::set_substructure(int index, const char* value) {
  ABSL_DCHECK(value != nullptr);
  _internal_mutable_substructure()->Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:dunedaq.opmon.OpMonId.substructure)
}
inline void OpMonId::set_substructure(int index, const char* value,
                              std::size_t size) {
  _internal_mutable_substructure()->Mutable(index)->assign(
      reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:dunedaq.opmon.OpMonId.substructure)
}
inline void OpMonId::set_substructure(int index, absl::string_view value) {
  _internal_mutable_substructure()->Mutable(index)->assign(value.data(),
                                                     value.size());
  // @@protoc_insertion_point(field_set_string_piece:dunedaq.opmon.OpMonId.substructure)
}
inline void OpMonId::add_substructure(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _internal_mutable_substructure()->Add()->assign(value);
  // @@protoc_insertion_point(field_add:dunedaq.opmon.OpMonId.substructure)
}
inline void OpMonId::add_substructure(std::string&& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _internal_mutable_substructure()->Add(std::move(value));
  // @@protoc_insertion_point(field_add:dunedaq.opmon.OpMonId.substructure)
}
inline void OpMonId::add_substructure(const char* value) {
  ABSL_DCHECK(value != nullptr);
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _internal_mutable_substructure()->Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:dunedaq.opmon.OpMonId.substructure)
}
inline void OpMonId::add_substructure(const char* value, std::size_t size) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _internal_mutable_substructure()->Add()->assign(
      reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:dunedaq.opmon.OpMonId.substructure)
}
inline void OpMonId::add_substructure(absl::string_view value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _internal_mutable_substructure()->Add()->assign(value.data(), value.size());
  // @@protoc_insertion_point(field_add_string_piece:dunedaq.opmon.OpMonId.substructure)
}
inline const ::google::protobuf::RepeatedPtrField<std::string>&
OpMonId::substructure() const {
  // @@protoc_insertion_point(field_list:dunedaq.opmon.OpMonId.substructure)
  return _internal_substructure();
}
inline ::google::protobuf::RepeatedPtrField<std::string>* OpMonId::mutable_substructure() {
  // @@protoc_insertion_point(field_mutable_list:dunedaq.opmon.OpMonId.substructure)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_substructure();
}
inline const ::google::protobuf::RepeatedPtrField<std::string>&
OpMonId::_internal_substructure() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.substructure_;
}
inline ::google::protobuf::RepeatedPtrField<std::string>*
OpMonId::_internal_mutable_substructure() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.substructure_;
}
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// OpMonEntry
 
// .google.protobuf.Timestamp time = 1;
inline bool OpMonEntry::has_time() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.time_ != nullptr);
  return value;
}
inline const ::google::protobuf::Timestamp& OpMonEntry::_internal_time() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::google::protobuf::Timestamp* p = _impl_.time_;
  return p != nullptr ? *p : reinterpret_cast<const ::google::protobuf::Timestamp&>(::google::protobuf::_Timestamp_default_instance_);
}
inline const ::google::protobuf::Timestamp& OpMonEntry::time() const {
  // @@protoc_insertion_point(field_get:dunedaq.opmon.OpMonEntry.time)
  return _internal_time();
}
inline void OpMonEntry::unsafe_arena_set_allocated_time(::google::protobuf::Timestamp* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.time_);
  }
  _impl_.time_ = reinterpret_cast<::google::protobuf::Timestamp*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dunedaq.opmon.OpMonEntry.time)
}
inline ::google::protobuf::Timestamp* OpMonEntry::release_time() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
 
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::google::protobuf::Timestamp* released = _impl_.time_;
  _impl_.time_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArenaForAllocation() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::google::protobuf::Timestamp* OpMonEntry::unsafe_arena_release_time() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:dunedaq.opmon.OpMonEntry.time)
 
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::google::protobuf::Timestamp* temp = _impl_.time_;
  _impl_.time_ = nullptr;
  return temp;
}
inline ::google::protobuf::Timestamp* OpMonEntry::_internal_mutable_time() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.time_ == nullptr) {
    auto* p = CreateMaybeMessage<::google::protobuf::Timestamp>(GetArenaForAllocation());
    _impl_.time_ = reinterpret_cast<::google::protobuf::Timestamp*>(p);
  }
  return _impl_.time_;
}
inline ::google::protobuf::Timestamp* OpMonEntry::mutable_time() {
  ::google::protobuf::Timestamp* _msg = _internal_mutable_time();
  // @@protoc_insertion_point(field_mutable:dunedaq.opmon.OpMonEntry.time)
  return _msg;
}
inline void OpMonEntry::set_allocated_time(::google::protobuf::Timestamp* value) {
  ::google::protobuf::Arena* message_arena = GetArenaForAllocation();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.time_);
  }
 
  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena =
        ::google::protobuf::Arena::InternalGetOwningArena(reinterpret_cast<::google::protobuf::MessageLite*>(value));
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
 
  _impl_.time_ = reinterpret_cast<::google::protobuf::Timestamp*>(value);
  // @@protoc_insertion_point(field_set_allocated:dunedaq.opmon.OpMonEntry.time)
}
 
// .dunedaq.opmon.OpMonId origin = 2;
inline bool OpMonEntry::has_origin() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.origin_ != nullptr);
  return value;
}
inline void OpMonEntry::clear_origin() {
  if (_impl_.origin_ != nullptr) _impl_.origin_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::dunedaq::opmon::OpMonId& OpMonEntry::_internal_origin() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::dunedaq::opmon::OpMonId* p = _impl_.origin_;
  return p != nullptr ? *p : reinterpret_cast<const ::dunedaq::opmon::OpMonId&>(::dunedaq::opmon::_OpMonId_default_instance_);
}
inline const ::dunedaq::opmon::OpMonId& OpMonEntry::origin() const {
  // @@protoc_insertion_point(field_get:dunedaq.opmon.OpMonEntry.origin)
  return _internal_origin();
}
inline void OpMonEntry::unsafe_arena_set_allocated_origin(::dunedaq::opmon::OpMonId* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.origin_);
  }
  _impl_.origin_ = reinterpret_cast<::dunedaq::opmon::OpMonId*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dunedaq.opmon.OpMonEntry.origin)
}
inline ::dunedaq::opmon::OpMonId* OpMonEntry::release_origin() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
 
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::dunedaq::opmon::OpMonId* released = _impl_.origin_;
  _impl_.origin_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArenaForAllocation() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::dunedaq::opmon::OpMonId* OpMonEntry::unsafe_arena_release_origin() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:dunedaq.opmon.OpMonEntry.origin)
 
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::dunedaq::opmon::OpMonId* temp = _impl_.origin_;
  _impl_.origin_ = nullptr;
  return temp;
}
inline ::dunedaq::opmon::OpMonId* OpMonEntry::_internal_mutable_origin() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.origin_ == nullptr) {
    auto* p = CreateMaybeMessage<::dunedaq::opmon::OpMonId>(GetArenaForAllocation());
    _impl_.origin_ = reinterpret_cast<::dunedaq::opmon::OpMonId*>(p);
  }
  return _impl_.origin_;
}
inline ::dunedaq::opmon::OpMonId* OpMonEntry::mutable_origin() {
  ::dunedaq::opmon::OpMonId* _msg = _internal_mutable_origin();
  // @@protoc_insertion_point(field_mutable:dunedaq.opmon.OpMonEntry.origin)
  return _msg;
}
inline void OpMonEntry::set_allocated_origin(::dunedaq::opmon::OpMonId* value) {
  ::google::protobuf::Arena* message_arena = GetArenaForAllocation();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::dunedaq::opmon::OpMonId*>(_impl_.origin_);
  }
 
  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena =
        ::google::protobuf::Arena::InternalGetOwningArena(reinterpret_cast<::dunedaq::opmon::OpMonId*>(value));
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
 
  _impl_.origin_ = reinterpret_cast<::dunedaq::opmon::OpMonId*>(value);
  // @@protoc_insertion_point(field_set_allocated:dunedaq.opmon.OpMonEntry.origin)
}
 
// map<string, string> custom_origin = 3;
inline int OpMonEntry::_internal_custom_origin_size() const {
  return _internal_custom_origin().size();
}
inline int OpMonEntry::custom_origin_size() const {
  return _internal_custom_origin_size();
}
inline void OpMonEntry::clear_custom_origin() {
  _impl_.custom_origin_.Clear();
}
inline const ::google::protobuf::Map<std::string, std::string>& OpMonEntry::_internal_custom_origin() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.custom_origin_.GetMap();
}
inline const ::google::protobuf::Map<std::string, std::string>& OpMonEntry::custom_origin() const {
  // @@protoc_insertion_point(field_map:dunedaq.opmon.OpMonEntry.custom_origin)
  return _internal_custom_origin();
}
inline ::google::protobuf::Map<std::string, std::string>* OpMonEntry::_internal_mutable_custom_origin() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _impl_.custom_origin_.MutableMap();
}
inline ::google::protobuf::Map<std::string, std::string>* OpMonEntry::mutable_custom_origin() {
  // @@protoc_insertion_point(field_mutable_map:dunedaq.opmon.OpMonEntry.custom_origin)
  return _internal_mutable_custom_origin();
}
 
// string measurement = 5;
inline void OpMonEntry::clear_measurement() {
  _impl_.measurement_.ClearToEmpty();
}
inline const std::string& OpMonEntry::measurement() const {
  // @@protoc_insertion_point(field_get:dunedaq.opmon.OpMonEntry.measurement)
  return _internal_measurement();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void OpMonEntry::set_measurement(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.measurement_.Set(static_cast<Arg_&&>(arg), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:dunedaq.opmon.OpMonEntry.measurement)
}
inline std::string* OpMonEntry::mutable_measurement() {
  std::string* _s = _internal_mutable_measurement();
  // @@protoc_insertion_point(field_mutable:dunedaq.opmon.OpMonEntry.measurement)
  return _s;
}
inline const std::string& OpMonEntry::_internal_measurement() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.measurement_.Get();
}
inline void OpMonEntry::_internal_set_measurement(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.measurement_.Set(value, GetArenaForAllocation());
}
inline std::string* OpMonEntry::_internal_mutable_measurement() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.measurement_.Mutable( GetArenaForAllocation());
}
inline std::string* OpMonEntry::release_measurement() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:dunedaq.opmon.OpMonEntry.measurement)
  return _impl_.measurement_.Release();
}
inline void OpMonEntry::set_allocated_measurement(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.measurement_.SetAllocated(value, GetArenaForAllocation());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.measurement_.IsDefault()) {
          _impl_.measurement_.Set("", GetArenaForAllocation());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:dunedaq.opmon.OpMonEntry.measurement)
}
 
// map<string, .dunedaq.opmon.OpMonValue> data = 10;
inline int OpMonEntry::_internal_data_size() const {
  return _internal_data().size();
}
inline int OpMonEntry::data_size() const {
  return _internal_data_size();
}
inline void OpMonEntry::clear_data() {
  _impl_.data_.Clear();
}
inline const ::google::protobuf::Map<std::string, ::dunedaq::opmon::OpMonValue>& OpMonEntry::_internal_data() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.data_.GetMap();
}
inline const ::google::protobuf::Map<std::string, ::dunedaq::opmon::OpMonValue>& OpMonEntry::data() const {
  // @@protoc_insertion_point(field_map:dunedaq.opmon.OpMonEntry.data)
  return _internal_data();
}
inline ::google::protobuf::Map<std::string, ::dunedaq::opmon::OpMonValue>* OpMonEntry::_internal_mutable_data() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _impl_.data_.MutableMap();
}
inline ::google::protobuf::Map<std::string, ::dunedaq::opmon::OpMonValue>* OpMonEntry::mutable_data() {
  // @@protoc_insertion_point(field_mutable_map:dunedaq.opmon.OpMonEntry.data)
  return _internal_mutable_data();
}
 
#ifdef __GNUC__
#pragma GCC diagnostic pop
#endif  // __GNUC__
 
// @@protoc_insertion_point(namespace_scope)
}  // namespace opmon
}  // namespace dunedaq
 
 
namespace google {
namespace protobuf {
 
template <>
struct is_proto_enum<::dunedaq::opmon::NullValue> : std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor<::dunedaq::opmon::NullValue>() {
  return ::dunedaq::opmon::NullValue_descriptor();
}
 
}  // namespace protobuf
}  // namespace google
 
// @@protoc_insertion_point(global_scope)
 
#include "google/protobuf/port_undef.inc"
 
#endif  // GOOGLE_PROTOBUF_INCLUDED_opmonlib_2fopmon_5fentry_2eproto_2epb_2eh