[VOL-5452] Added new RPCs and enums for component states as well as reset/enable/disable of components
Change-Id: I03781f71f8f7829c54d6b73298742f7bea364e41
Signed-off-by: Amit Ghosh <amit.ghosh@radisys.com>
diff --git a/cpp/dmi/hw_events_mgmt_service.pb.h b/cpp/dmi/hw_events_mgmt_service.pb.h
index 4c4dfe9..7e3e8bd 100644
--- a/cpp/dmi/hw_events_mgmt_service.pb.h
+++ b/cpp/dmi/hw_events_mgmt_service.pb.h
@@ -46,7 +46,7 @@
PROTOBUF_SECTION_VARIABLE(protodesc_cold);
static const ::google::protobuf::internal::AuxillaryParseTableField aux[]
PROTOBUF_SECTION_VARIABLE(protodesc_cold);
- static const ::google::protobuf::internal::ParseTable schema[11]
+ static const ::google::protobuf::internal::ParseTable schema[17]
PROTOBUF_SECTION_VARIABLE(protodesc_cold);
static const ::google::protobuf::internal::FieldMetadata field_metadata[];
static const ::google::protobuf::internal::SerializationTable serialization_table[];
@@ -54,6 +54,12 @@
};
void AddDescriptors_dmi_2fhw_5fevents_5fmgmt_5fservice_2eproto();
namespace dmi {
+class AdminStateChange;
+class AdminStateChangeDefaultTypeInternal;
+extern AdminStateChangeDefaultTypeInternal _AdminStateChange_default_instance_;
+class AlarmStateChange;
+class AlarmStateChangeDefaultTypeInternal;
+extern AlarmStateChangeDefaultTypeInternal _AlarmStateChange_default_instance_;
class Event;
class EventDefaultTypeInternal;
extern EventDefaultTypeInternal _Event_default_instance_;
@@ -75,12 +81,24 @@
class ListEventsResponse;
class ListEventsResponseDefaultTypeInternal;
extern ListEventsResponseDefaultTypeInternal _ListEventsResponse_default_instance_;
+class OperStateChange;
+class OperStateChangeDefaultTypeInternal;
+extern OperStateChangeDefaultTypeInternal _OperStateChange_default_instance_;
+class StandbyStateChange;
+class StandbyStateChangeDefaultTypeInternal;
+extern StandbyStateChangeDefaultTypeInternal _StandbyStateChange_default_instance_;
+class StateChangeInfo;
+class StateChangeInfoDefaultTypeInternal;
+extern StateChangeInfoDefaultTypeInternal _StateChangeInfo_default_instance_;
class ThresholdInformation;
class ThresholdInformationDefaultTypeInternal;
extern ThresholdInformationDefaultTypeInternal _ThresholdInformation_default_instance_;
class Thresholds;
class ThresholdsDefaultTypeInternal;
extern ThresholdsDefaultTypeInternal _Thresholds_default_instance_;
+class UsageStateChange;
+class UsageStateChangeDefaultTypeInternal;
+extern UsageStateChangeDefaultTypeInternal _UsageStateChange_default_instance_;
class ValueType;
class ValueTypeDefaultTypeInternal;
extern ValueTypeDefaultTypeInternal _ValueType_default_instance_;
@@ -90,6 +108,8 @@
} // namespace dmi
namespace google {
namespace protobuf {
+template<> ::dmi::AdminStateChange* Arena::CreateMaybeMessage<::dmi::AdminStateChange>(Arena*);
+template<> ::dmi::AlarmStateChange* Arena::CreateMaybeMessage<::dmi::AlarmStateChange>(Arena*);
template<> ::dmi::Event* Arena::CreateMaybeMessage<::dmi::Event>(Arena*);
template<> ::dmi::EventCfg* Arena::CreateMaybeMessage<::dmi::EventCfg>(Arena*);
template<> ::dmi::EventMetaData* Arena::CreateMaybeMessage<::dmi::EventMetaData>(Arena*);
@@ -97,8 +117,12 @@
template<> ::dmi::EventsConfigurationRequest* Arena::CreateMaybeMessage<::dmi::EventsConfigurationRequest>(Arena*);
template<> ::dmi::EventsConfigurationResponse* Arena::CreateMaybeMessage<::dmi::EventsConfigurationResponse>(Arena*);
template<> ::dmi::ListEventsResponse* Arena::CreateMaybeMessage<::dmi::ListEventsResponse>(Arena*);
+template<> ::dmi::OperStateChange* Arena::CreateMaybeMessage<::dmi::OperStateChange>(Arena*);
+template<> ::dmi::StandbyStateChange* Arena::CreateMaybeMessage<::dmi::StandbyStateChange>(Arena*);
+template<> ::dmi::StateChangeInfo* Arena::CreateMaybeMessage<::dmi::StateChangeInfo>(Arena*);
template<> ::dmi::ThresholdInformation* Arena::CreateMaybeMessage<::dmi::ThresholdInformation>(Arena*);
template<> ::dmi::Thresholds* Arena::CreateMaybeMessage<::dmi::Thresholds>(Arena*);
+template<> ::dmi::UsageStateChange* Arena::CreateMaybeMessage<::dmi::UsageStateChange>(Arena*);
template<> ::dmi::ValueType* Arena::CreateMaybeMessage<::dmi::ValueType>(Arena*);
template<> ::dmi::WaterMarks* Arena::CreateMaybeMessage<::dmi::WaterMarks>(Arena*);
} // namespace protobuf
@@ -208,12 +232,17 @@
EVENT_HW_NTP_SYNC_FAILURE_RECOVERED = 513,
EVENT_LINE_CARD_PLUG_OUT = 600,
EVENT_LINE_CARD_PLUG_IN = 601,
+ EVENT_COMPONENT_ADMIN_STATE_CHANGED = 700,
+ EVENT_COMPONENT_OPER_STATE_CHANGED = 701,
+ EVENT_COMPONENT_ALARM_STATE_CHANGED = 702,
+ EVENT_COMPONENT_USAGE_STATE_CHANGED = 703,
+ EVENT_COMPONENT_STANDBY_STATE_CHANGED = 704,
EventIds_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::google::protobuf::int32>::min(),
EventIds_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::google::protobuf::int32>::max()
};
bool EventIds_IsValid(int value);
const EventIds EventIds_MIN = EVENT_NAME_UNDEFINED;
-const EventIds EventIds_MAX = EVENT_LINE_CARD_PLUG_IN;
+const EventIds EventIds_MAX = EVENT_COMPONENT_STANDBY_STATE_CHANGED;
const int EventIds_ARRAYSIZE = EventIds_MAX + 1;
const ::google::protobuf::EnumDescriptor* EventIds_descriptor();
@@ -1673,6 +1702,780 @@
};
// -------------------------------------------------------------------
+class AdminStateChange final :
+ public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dmi.AdminStateChange) */ {
+ public:
+ AdminStateChange();
+ virtual ~AdminStateChange();
+
+ AdminStateChange(const AdminStateChange& from);
+
+ inline AdminStateChange& operator=(const AdminStateChange& from) {
+ CopyFrom(from);
+ return *this;
+ }
+ #if LANG_CXX11
+ AdminStateChange(AdminStateChange&& from) noexcept
+ : AdminStateChange() {
+ *this = ::std::move(from);
+ }
+
+ inline AdminStateChange& operator=(AdminStateChange&& from) noexcept {
+ if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+ if (this != &from) InternalSwap(&from);
+ } else {
+ CopyFrom(from);
+ }
+ return *this;
+ }
+ #endif
+ static const ::google::protobuf::Descriptor* descriptor() {
+ return default_instance().GetDescriptor();
+ }
+ static const AdminStateChange& default_instance();
+
+ static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
+ static inline const AdminStateChange* internal_default_instance() {
+ return reinterpret_cast<const AdminStateChange*>(
+ &_AdminStateChange_default_instance_);
+ }
+ static constexpr int kIndexInFileMessages =
+ 10;
+
+ void Swap(AdminStateChange* other);
+ friend void swap(AdminStateChange& a, AdminStateChange& b) {
+ a.Swap(&b);
+ }
+
+ // implements Message ----------------------------------------------
+
+ inline AdminStateChange* New() const final {
+ return CreateMaybeMessage<AdminStateChange>(nullptr);
+ }
+
+ AdminStateChange* New(::google::protobuf::Arena* arena) const final {
+ return CreateMaybeMessage<AdminStateChange>(arena);
+ }
+ void CopyFrom(const ::google::protobuf::Message& from) final;
+ void MergeFrom(const ::google::protobuf::Message& from) final;
+ void CopyFrom(const AdminStateChange& from);
+ void MergeFrom(const AdminStateChange& from);
+ PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+ bool IsInitialized() const final;
+
+ size_t ByteSizeLong() const final;
+ #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+ static const char* _InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx);
+ ::google::protobuf::internal::ParseFunc _ParseFunc() const final { return _InternalParse; }
+ #else
+ bool MergePartialFromCodedStream(
+ ::google::protobuf::io::CodedInputStream* input) final;
+ #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+ void SerializeWithCachedSizes(
+ ::google::protobuf::io::CodedOutputStream* output) const final;
+ ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+ ::google::protobuf::uint8* target) const final;
+ int GetCachedSize() const final { return _cached_size_.Get(); }
+
+ private:
+ void SharedCtor();
+ void SharedDtor();
+ void SetCachedSize(int size) const final;
+ void InternalSwap(AdminStateChange* other);
+ private:
+ inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+ return nullptr;
+ }
+ inline void* MaybeArenaPtr() const {
+ return nullptr;
+ }
+ public:
+
+ ::google::protobuf::Metadata GetMetadata() const final;
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ // .dmi.ComponentAdminState old = 1;
+ void clear_old();
+ static const int kOldFieldNumber = 1;
+ ::dmi::ComponentAdminState old() const;
+ void set_old(::dmi::ComponentAdminState value);
+
+ // .dmi.ComponentAdminState new = 2;
+ void clear_new_();
+ static const int kNewFieldNumber = 2;
+ ::dmi::ComponentAdminState new_() const;
+ void set_new_(::dmi::ComponentAdminState value);
+
+ // @@protoc_insertion_point(class_scope:dmi.AdminStateChange)
+ private:
+ class HasBitSetters;
+
+ ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+ int old_;
+ int new__;
+ mutable ::google::protobuf::internal::CachedSize _cached_size_;
+ friend struct ::TableStruct_dmi_2fhw_5fevents_5fmgmt_5fservice_2eproto;
+};
+// -------------------------------------------------------------------
+
+class OperStateChange final :
+ public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dmi.OperStateChange) */ {
+ public:
+ OperStateChange();
+ virtual ~OperStateChange();
+
+ OperStateChange(const OperStateChange& from);
+
+ inline OperStateChange& operator=(const OperStateChange& from) {
+ CopyFrom(from);
+ return *this;
+ }
+ #if LANG_CXX11
+ OperStateChange(OperStateChange&& from) noexcept
+ : OperStateChange() {
+ *this = ::std::move(from);
+ }
+
+ inline OperStateChange& operator=(OperStateChange&& from) noexcept {
+ if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+ if (this != &from) InternalSwap(&from);
+ } else {
+ CopyFrom(from);
+ }
+ return *this;
+ }
+ #endif
+ static const ::google::protobuf::Descriptor* descriptor() {
+ return default_instance().GetDescriptor();
+ }
+ static const OperStateChange& default_instance();
+
+ static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
+ static inline const OperStateChange* internal_default_instance() {
+ return reinterpret_cast<const OperStateChange*>(
+ &_OperStateChange_default_instance_);
+ }
+ static constexpr int kIndexInFileMessages =
+ 11;
+
+ void Swap(OperStateChange* other);
+ friend void swap(OperStateChange& a, OperStateChange& b) {
+ a.Swap(&b);
+ }
+
+ // implements Message ----------------------------------------------
+
+ inline OperStateChange* New() const final {
+ return CreateMaybeMessage<OperStateChange>(nullptr);
+ }
+
+ OperStateChange* New(::google::protobuf::Arena* arena) const final {
+ return CreateMaybeMessage<OperStateChange>(arena);
+ }
+ void CopyFrom(const ::google::protobuf::Message& from) final;
+ void MergeFrom(const ::google::protobuf::Message& from) final;
+ void CopyFrom(const OperStateChange& from);
+ void MergeFrom(const OperStateChange& from);
+ PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+ bool IsInitialized() const final;
+
+ size_t ByteSizeLong() const final;
+ #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+ static const char* _InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx);
+ ::google::protobuf::internal::ParseFunc _ParseFunc() const final { return _InternalParse; }
+ #else
+ bool MergePartialFromCodedStream(
+ ::google::protobuf::io::CodedInputStream* input) final;
+ #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+ void SerializeWithCachedSizes(
+ ::google::protobuf::io::CodedOutputStream* output) const final;
+ ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+ ::google::protobuf::uint8* target) const final;
+ int GetCachedSize() const final { return _cached_size_.Get(); }
+
+ private:
+ void SharedCtor();
+ void SharedDtor();
+ void SetCachedSize(int size) const final;
+ void InternalSwap(OperStateChange* other);
+ private:
+ inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+ return nullptr;
+ }
+ inline void* MaybeArenaPtr() const {
+ return nullptr;
+ }
+ public:
+
+ ::google::protobuf::Metadata GetMetadata() const final;
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ // .dmi.ComponentOperState old = 1;
+ void clear_old();
+ static const int kOldFieldNumber = 1;
+ ::dmi::ComponentOperState old() const;
+ void set_old(::dmi::ComponentOperState value);
+
+ // .dmi.ComponentOperState new = 2;
+ void clear_new_();
+ static const int kNewFieldNumber = 2;
+ ::dmi::ComponentOperState new_() const;
+ void set_new_(::dmi::ComponentOperState value);
+
+ // @@protoc_insertion_point(class_scope:dmi.OperStateChange)
+ private:
+ class HasBitSetters;
+
+ ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+ int old_;
+ int new__;
+ mutable ::google::protobuf::internal::CachedSize _cached_size_;
+ friend struct ::TableStruct_dmi_2fhw_5fevents_5fmgmt_5fservice_2eproto;
+};
+// -------------------------------------------------------------------
+
+class AlarmStateChange final :
+ public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dmi.AlarmStateChange) */ {
+ public:
+ AlarmStateChange();
+ virtual ~AlarmStateChange();
+
+ AlarmStateChange(const AlarmStateChange& from);
+
+ inline AlarmStateChange& operator=(const AlarmStateChange& from) {
+ CopyFrom(from);
+ return *this;
+ }
+ #if LANG_CXX11
+ AlarmStateChange(AlarmStateChange&& from) noexcept
+ : AlarmStateChange() {
+ *this = ::std::move(from);
+ }
+
+ inline AlarmStateChange& operator=(AlarmStateChange&& from) noexcept {
+ if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+ if (this != &from) InternalSwap(&from);
+ } else {
+ CopyFrom(from);
+ }
+ return *this;
+ }
+ #endif
+ static const ::google::protobuf::Descriptor* descriptor() {
+ return default_instance().GetDescriptor();
+ }
+ static const AlarmStateChange& default_instance();
+
+ static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
+ static inline const AlarmStateChange* internal_default_instance() {
+ return reinterpret_cast<const AlarmStateChange*>(
+ &_AlarmStateChange_default_instance_);
+ }
+ static constexpr int kIndexInFileMessages =
+ 12;
+
+ void Swap(AlarmStateChange* other);
+ friend void swap(AlarmStateChange& a, AlarmStateChange& b) {
+ a.Swap(&b);
+ }
+
+ // implements Message ----------------------------------------------
+
+ inline AlarmStateChange* New() const final {
+ return CreateMaybeMessage<AlarmStateChange>(nullptr);
+ }
+
+ AlarmStateChange* New(::google::protobuf::Arena* arena) const final {
+ return CreateMaybeMessage<AlarmStateChange>(arena);
+ }
+ void CopyFrom(const ::google::protobuf::Message& from) final;
+ void MergeFrom(const ::google::protobuf::Message& from) final;
+ void CopyFrom(const AlarmStateChange& from);
+ void MergeFrom(const AlarmStateChange& from);
+ PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+ bool IsInitialized() const final;
+
+ size_t ByteSizeLong() const final;
+ #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+ static const char* _InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx);
+ ::google::protobuf::internal::ParseFunc _ParseFunc() const final { return _InternalParse; }
+ #else
+ bool MergePartialFromCodedStream(
+ ::google::protobuf::io::CodedInputStream* input) final;
+ #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+ void SerializeWithCachedSizes(
+ ::google::protobuf::io::CodedOutputStream* output) const final;
+ ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+ ::google::protobuf::uint8* target) const final;
+ int GetCachedSize() const final { return _cached_size_.Get(); }
+
+ private:
+ void SharedCtor();
+ void SharedDtor();
+ void SetCachedSize(int size) const final;
+ void InternalSwap(AlarmStateChange* other);
+ private:
+ inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+ return nullptr;
+ }
+ inline void* MaybeArenaPtr() const {
+ return nullptr;
+ }
+ public:
+
+ ::google::protobuf::Metadata GetMetadata() const final;
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ // .dmi.ComponentAlarmState old = 1;
+ void clear_old();
+ static const int kOldFieldNumber = 1;
+ ::dmi::ComponentAlarmState old() const;
+ void set_old(::dmi::ComponentAlarmState value);
+
+ // .dmi.ComponentAlarmState new = 2;
+ void clear_new_();
+ static const int kNewFieldNumber = 2;
+ ::dmi::ComponentAlarmState new_() const;
+ void set_new_(::dmi::ComponentAlarmState value);
+
+ // @@protoc_insertion_point(class_scope:dmi.AlarmStateChange)
+ private:
+ class HasBitSetters;
+
+ ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+ int old_;
+ int new__;
+ mutable ::google::protobuf::internal::CachedSize _cached_size_;
+ friend struct ::TableStruct_dmi_2fhw_5fevents_5fmgmt_5fservice_2eproto;
+};
+// -------------------------------------------------------------------
+
+class UsageStateChange final :
+ public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dmi.UsageStateChange) */ {
+ public:
+ UsageStateChange();
+ virtual ~UsageStateChange();
+
+ UsageStateChange(const UsageStateChange& from);
+
+ inline UsageStateChange& operator=(const UsageStateChange& from) {
+ CopyFrom(from);
+ return *this;
+ }
+ #if LANG_CXX11
+ UsageStateChange(UsageStateChange&& from) noexcept
+ : UsageStateChange() {
+ *this = ::std::move(from);
+ }
+
+ inline UsageStateChange& operator=(UsageStateChange&& from) noexcept {
+ if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+ if (this != &from) InternalSwap(&from);
+ } else {
+ CopyFrom(from);
+ }
+ return *this;
+ }
+ #endif
+ static const ::google::protobuf::Descriptor* descriptor() {
+ return default_instance().GetDescriptor();
+ }
+ static const UsageStateChange& default_instance();
+
+ static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
+ static inline const UsageStateChange* internal_default_instance() {
+ return reinterpret_cast<const UsageStateChange*>(
+ &_UsageStateChange_default_instance_);
+ }
+ static constexpr int kIndexInFileMessages =
+ 13;
+
+ void Swap(UsageStateChange* other);
+ friend void swap(UsageStateChange& a, UsageStateChange& b) {
+ a.Swap(&b);
+ }
+
+ // implements Message ----------------------------------------------
+
+ inline UsageStateChange* New() const final {
+ return CreateMaybeMessage<UsageStateChange>(nullptr);
+ }
+
+ UsageStateChange* New(::google::protobuf::Arena* arena) const final {
+ return CreateMaybeMessage<UsageStateChange>(arena);
+ }
+ void CopyFrom(const ::google::protobuf::Message& from) final;
+ void MergeFrom(const ::google::protobuf::Message& from) final;
+ void CopyFrom(const UsageStateChange& from);
+ void MergeFrom(const UsageStateChange& from);
+ PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+ bool IsInitialized() const final;
+
+ size_t ByteSizeLong() const final;
+ #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+ static const char* _InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx);
+ ::google::protobuf::internal::ParseFunc _ParseFunc() const final { return _InternalParse; }
+ #else
+ bool MergePartialFromCodedStream(
+ ::google::protobuf::io::CodedInputStream* input) final;
+ #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+ void SerializeWithCachedSizes(
+ ::google::protobuf::io::CodedOutputStream* output) const final;
+ ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+ ::google::protobuf::uint8* target) const final;
+ int GetCachedSize() const final { return _cached_size_.Get(); }
+
+ private:
+ void SharedCtor();
+ void SharedDtor();
+ void SetCachedSize(int size) const final;
+ void InternalSwap(UsageStateChange* other);
+ private:
+ inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+ return nullptr;
+ }
+ inline void* MaybeArenaPtr() const {
+ return nullptr;
+ }
+ public:
+
+ ::google::protobuf::Metadata GetMetadata() const final;
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ // .dmi.ComponentUsageState old = 1;
+ void clear_old();
+ static const int kOldFieldNumber = 1;
+ ::dmi::ComponentUsageState old() const;
+ void set_old(::dmi::ComponentUsageState value);
+
+ // .dmi.ComponentUsageState new = 2;
+ void clear_new_();
+ static const int kNewFieldNumber = 2;
+ ::dmi::ComponentUsageState new_() const;
+ void set_new_(::dmi::ComponentUsageState value);
+
+ // @@protoc_insertion_point(class_scope:dmi.UsageStateChange)
+ private:
+ class HasBitSetters;
+
+ ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+ int old_;
+ int new__;
+ mutable ::google::protobuf::internal::CachedSize _cached_size_;
+ friend struct ::TableStruct_dmi_2fhw_5fevents_5fmgmt_5fservice_2eproto;
+};
+// -------------------------------------------------------------------
+
+class StandbyStateChange final :
+ public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dmi.StandbyStateChange) */ {
+ public:
+ StandbyStateChange();
+ virtual ~StandbyStateChange();
+
+ StandbyStateChange(const StandbyStateChange& from);
+
+ inline StandbyStateChange& operator=(const StandbyStateChange& from) {
+ CopyFrom(from);
+ return *this;
+ }
+ #if LANG_CXX11
+ StandbyStateChange(StandbyStateChange&& from) noexcept
+ : StandbyStateChange() {
+ *this = ::std::move(from);
+ }
+
+ inline StandbyStateChange& operator=(StandbyStateChange&& from) noexcept {
+ if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+ if (this != &from) InternalSwap(&from);
+ } else {
+ CopyFrom(from);
+ }
+ return *this;
+ }
+ #endif
+ static const ::google::protobuf::Descriptor* descriptor() {
+ return default_instance().GetDescriptor();
+ }
+ static const StandbyStateChange& default_instance();
+
+ static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
+ static inline const StandbyStateChange* internal_default_instance() {
+ return reinterpret_cast<const StandbyStateChange*>(
+ &_StandbyStateChange_default_instance_);
+ }
+ static constexpr int kIndexInFileMessages =
+ 14;
+
+ void Swap(StandbyStateChange* other);
+ friend void swap(StandbyStateChange& a, StandbyStateChange& b) {
+ a.Swap(&b);
+ }
+
+ // implements Message ----------------------------------------------
+
+ inline StandbyStateChange* New() const final {
+ return CreateMaybeMessage<StandbyStateChange>(nullptr);
+ }
+
+ StandbyStateChange* New(::google::protobuf::Arena* arena) const final {
+ return CreateMaybeMessage<StandbyStateChange>(arena);
+ }
+ void CopyFrom(const ::google::protobuf::Message& from) final;
+ void MergeFrom(const ::google::protobuf::Message& from) final;
+ void CopyFrom(const StandbyStateChange& from);
+ void MergeFrom(const StandbyStateChange& from);
+ PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+ bool IsInitialized() const final;
+
+ size_t ByteSizeLong() const final;
+ #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+ static const char* _InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx);
+ ::google::protobuf::internal::ParseFunc _ParseFunc() const final { return _InternalParse; }
+ #else
+ bool MergePartialFromCodedStream(
+ ::google::protobuf::io::CodedInputStream* input) final;
+ #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+ void SerializeWithCachedSizes(
+ ::google::protobuf::io::CodedOutputStream* output) const final;
+ ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+ ::google::protobuf::uint8* target) const final;
+ int GetCachedSize() const final { return _cached_size_.Get(); }
+
+ private:
+ void SharedCtor();
+ void SharedDtor();
+ void SetCachedSize(int size) const final;
+ void InternalSwap(StandbyStateChange* other);
+ private:
+ inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+ return nullptr;
+ }
+ inline void* MaybeArenaPtr() const {
+ return nullptr;
+ }
+ public:
+
+ ::google::protobuf::Metadata GetMetadata() const final;
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ // .dmi.ComponentStandbyState old = 1;
+ void clear_old();
+ static const int kOldFieldNumber = 1;
+ ::dmi::ComponentStandbyState old() const;
+ void set_old(::dmi::ComponentStandbyState value);
+
+ // .dmi.ComponentStandbyState new = 2;
+ void clear_new_();
+ static const int kNewFieldNumber = 2;
+ ::dmi::ComponentStandbyState new_() const;
+ void set_new_(::dmi::ComponentStandbyState value);
+
+ // @@protoc_insertion_point(class_scope:dmi.StandbyStateChange)
+ private:
+ class HasBitSetters;
+
+ ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+ int old_;
+ int new__;
+ mutable ::google::protobuf::internal::CachedSize _cached_size_;
+ friend struct ::TableStruct_dmi_2fhw_5fevents_5fmgmt_5fservice_2eproto;
+};
+// -------------------------------------------------------------------
+
+class StateChangeInfo final :
+ public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dmi.StateChangeInfo) */ {
+ public:
+ StateChangeInfo();
+ virtual ~StateChangeInfo();
+
+ StateChangeInfo(const StateChangeInfo& from);
+
+ inline StateChangeInfo& operator=(const StateChangeInfo& from) {
+ CopyFrom(from);
+ return *this;
+ }
+ #if LANG_CXX11
+ StateChangeInfo(StateChangeInfo&& from) noexcept
+ : StateChangeInfo() {
+ *this = ::std::move(from);
+ }
+
+ inline StateChangeInfo& operator=(StateChangeInfo&& from) noexcept {
+ if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+ if (this != &from) InternalSwap(&from);
+ } else {
+ CopyFrom(from);
+ }
+ return *this;
+ }
+ #endif
+ static const ::google::protobuf::Descriptor* descriptor() {
+ return default_instance().GetDescriptor();
+ }
+ static const StateChangeInfo& default_instance();
+
+ enum StateChangeCase {
+ kAdminStateChange = 1,
+ kOperStateChange = 2,
+ kAlarmStateChange = 3,
+ kUsageStateChange = 4,
+ kStandbyStateChange = 5,
+ STATE_CHANGE_NOT_SET = 0,
+ };
+
+ static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
+ static inline const StateChangeInfo* internal_default_instance() {
+ return reinterpret_cast<const StateChangeInfo*>(
+ &_StateChangeInfo_default_instance_);
+ }
+ static constexpr int kIndexInFileMessages =
+ 15;
+
+ void Swap(StateChangeInfo* other);
+ friend void swap(StateChangeInfo& a, StateChangeInfo& b) {
+ a.Swap(&b);
+ }
+
+ // implements Message ----------------------------------------------
+
+ inline StateChangeInfo* New() const final {
+ return CreateMaybeMessage<StateChangeInfo>(nullptr);
+ }
+
+ StateChangeInfo* New(::google::protobuf::Arena* arena) const final {
+ return CreateMaybeMessage<StateChangeInfo>(arena);
+ }
+ void CopyFrom(const ::google::protobuf::Message& from) final;
+ void MergeFrom(const ::google::protobuf::Message& from) final;
+ void CopyFrom(const StateChangeInfo& from);
+ void MergeFrom(const StateChangeInfo& from);
+ PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+ bool IsInitialized() const final;
+
+ size_t ByteSizeLong() const final;
+ #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+ static const char* _InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx);
+ ::google::protobuf::internal::ParseFunc _ParseFunc() const final { return _InternalParse; }
+ #else
+ bool MergePartialFromCodedStream(
+ ::google::protobuf::io::CodedInputStream* input) final;
+ #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+ void SerializeWithCachedSizes(
+ ::google::protobuf::io::CodedOutputStream* output) const final;
+ ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+ ::google::protobuf::uint8* target) const final;
+ int GetCachedSize() const final { return _cached_size_.Get(); }
+
+ private:
+ void SharedCtor();
+ void SharedDtor();
+ void SetCachedSize(int size) const final;
+ void InternalSwap(StateChangeInfo* other);
+ private:
+ inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+ return nullptr;
+ }
+ inline void* MaybeArenaPtr() const {
+ return nullptr;
+ }
+ public:
+
+ ::google::protobuf::Metadata GetMetadata() const final;
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ // .dmi.AdminStateChange admin_state_change = 1;
+ bool has_admin_state_change() const;
+ void clear_admin_state_change();
+ static const int kAdminStateChangeFieldNumber = 1;
+ const ::dmi::AdminStateChange& admin_state_change() const;
+ ::dmi::AdminStateChange* release_admin_state_change();
+ ::dmi::AdminStateChange* mutable_admin_state_change();
+ void set_allocated_admin_state_change(::dmi::AdminStateChange* admin_state_change);
+
+ // .dmi.OperStateChange oper_state_change = 2;
+ bool has_oper_state_change() const;
+ void clear_oper_state_change();
+ static const int kOperStateChangeFieldNumber = 2;
+ const ::dmi::OperStateChange& oper_state_change() const;
+ ::dmi::OperStateChange* release_oper_state_change();
+ ::dmi::OperStateChange* mutable_oper_state_change();
+ void set_allocated_oper_state_change(::dmi::OperStateChange* oper_state_change);
+
+ // .dmi.AlarmStateChange alarm_state_change = 3;
+ bool has_alarm_state_change() const;
+ void clear_alarm_state_change();
+ static const int kAlarmStateChangeFieldNumber = 3;
+ const ::dmi::AlarmStateChange& alarm_state_change() const;
+ ::dmi::AlarmStateChange* release_alarm_state_change();
+ ::dmi::AlarmStateChange* mutable_alarm_state_change();
+ void set_allocated_alarm_state_change(::dmi::AlarmStateChange* alarm_state_change);
+
+ // .dmi.UsageStateChange usage_state_change = 4;
+ bool has_usage_state_change() const;
+ void clear_usage_state_change();
+ static const int kUsageStateChangeFieldNumber = 4;
+ const ::dmi::UsageStateChange& usage_state_change() const;
+ ::dmi::UsageStateChange* release_usage_state_change();
+ ::dmi::UsageStateChange* mutable_usage_state_change();
+ void set_allocated_usage_state_change(::dmi::UsageStateChange* usage_state_change);
+
+ // .dmi.StandbyStateChange standby_state_change = 5;
+ bool has_standby_state_change() const;
+ void clear_standby_state_change();
+ static const int kStandbyStateChangeFieldNumber = 5;
+ const ::dmi::StandbyStateChange& standby_state_change() const;
+ ::dmi::StandbyStateChange* release_standby_state_change();
+ ::dmi::StandbyStateChange* mutable_standby_state_change();
+ void set_allocated_standby_state_change(::dmi::StandbyStateChange* standby_state_change);
+
+ void clear_state_change();
+ StateChangeCase state_change_case() const;
+ // @@protoc_insertion_point(class_scope:dmi.StateChangeInfo)
+ private:
+ class HasBitSetters;
+ void set_has_admin_state_change();
+ void set_has_oper_state_change();
+ void set_has_alarm_state_change();
+ void set_has_usage_state_change();
+ void set_has_standby_state_change();
+
+ inline bool has_state_change() const;
+ inline void clear_has_state_change();
+
+ ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+ union StateChangeUnion {
+ StateChangeUnion() {}
+ ::dmi::AdminStateChange* admin_state_change_;
+ ::dmi::OperStateChange* oper_state_change_;
+ ::dmi::AlarmStateChange* alarm_state_change_;
+ ::dmi::UsageStateChange* usage_state_change_;
+ ::dmi::StandbyStateChange* standby_state_change_;
+ } state_change_;
+ mutable ::google::protobuf::internal::CachedSize _cached_size_;
+ ::google::protobuf::uint32 _oneof_case_[1];
+
+ friend struct ::TableStruct_dmi_2fhw_5fevents_5fmgmt_5fservice_2eproto;
+};
+// -------------------------------------------------------------------
+
class Event final :
public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dmi.Event) */ {
public:
@@ -1711,7 +2514,7 @@
&_Event_default_instance_);
}
static constexpr int kIndexInFileMessages =
- 10;
+ 16;
void Swap(Event* other);
friend void swap(Event& a, Event& b) {
@@ -1809,6 +2612,15 @@
::dmi::ThresholdInformation* mutable_threshold_info();
void set_allocated_threshold_info(::dmi::ThresholdInformation* threshold_info);
+ // .dmi.StateChangeInfo state_change_info = 6;
+ bool has_state_change_info() const;
+ void clear_state_change_info();
+ static const int kStateChangeInfoFieldNumber = 6;
+ const ::dmi::StateChangeInfo& state_change_info() const;
+ ::dmi::StateChangeInfo* release_state_change_info();
+ ::dmi::StateChangeInfo* mutable_state_change_info();
+ void set_allocated_state_change_info(::dmi::StateChangeInfo* state_change_info);
+
// .dmi.EventIds event_id = 2;
void clear_event_id();
static const int kEventIdFieldNumber = 2;
@@ -1824,6 +2636,7 @@
::dmi::EventMetaData* event_metadata_;
::google::protobuf::Timestamp* raised_ts_;
::dmi::ThresholdInformation* threshold_info_;
+ ::dmi::StateChangeInfo* state_change_info_;
int event_id_;
mutable ::google::protobuf::internal::CachedSize _cached_size_;
friend struct ::TableStruct_dmi_2fhw_5fevents_5fmgmt_5fservice_2eproto;
@@ -2916,6 +3729,384 @@
// -------------------------------------------------------------------
+// AdminStateChange
+
+// .dmi.ComponentAdminState old = 1;
+inline void AdminStateChange::clear_old() {
+ old_ = 0;
+}
+inline ::dmi::ComponentAdminState AdminStateChange::old() const {
+ // @@protoc_insertion_point(field_get:dmi.AdminStateChange.old)
+ return static_cast< ::dmi::ComponentAdminState >(old_);
+}
+inline void AdminStateChange::set_old(::dmi::ComponentAdminState value) {
+
+ old_ = value;
+ // @@protoc_insertion_point(field_set:dmi.AdminStateChange.old)
+}
+
+// .dmi.ComponentAdminState new = 2;
+inline void AdminStateChange::clear_new_() {
+ new__ = 0;
+}
+inline ::dmi::ComponentAdminState AdminStateChange::new_() const {
+ // @@protoc_insertion_point(field_get:dmi.AdminStateChange.new)
+ return static_cast< ::dmi::ComponentAdminState >(new__);
+}
+inline void AdminStateChange::set_new_(::dmi::ComponentAdminState value) {
+
+ new__ = value;
+ // @@protoc_insertion_point(field_set:dmi.AdminStateChange.new)
+}
+
+// -------------------------------------------------------------------
+
+// OperStateChange
+
+// .dmi.ComponentOperState old = 1;
+inline void OperStateChange::clear_old() {
+ old_ = 0;
+}
+inline ::dmi::ComponentOperState OperStateChange::old() const {
+ // @@protoc_insertion_point(field_get:dmi.OperStateChange.old)
+ return static_cast< ::dmi::ComponentOperState >(old_);
+}
+inline void OperStateChange::set_old(::dmi::ComponentOperState value) {
+
+ old_ = value;
+ // @@protoc_insertion_point(field_set:dmi.OperStateChange.old)
+}
+
+// .dmi.ComponentOperState new = 2;
+inline void OperStateChange::clear_new_() {
+ new__ = 0;
+}
+inline ::dmi::ComponentOperState OperStateChange::new_() const {
+ // @@protoc_insertion_point(field_get:dmi.OperStateChange.new)
+ return static_cast< ::dmi::ComponentOperState >(new__);
+}
+inline void OperStateChange::set_new_(::dmi::ComponentOperState value) {
+
+ new__ = value;
+ // @@protoc_insertion_point(field_set:dmi.OperStateChange.new)
+}
+
+// -------------------------------------------------------------------
+
+// AlarmStateChange
+
+// .dmi.ComponentAlarmState old = 1;
+inline void AlarmStateChange::clear_old() {
+ old_ = 0;
+}
+inline ::dmi::ComponentAlarmState AlarmStateChange::old() const {
+ // @@protoc_insertion_point(field_get:dmi.AlarmStateChange.old)
+ return static_cast< ::dmi::ComponentAlarmState >(old_);
+}
+inline void AlarmStateChange::set_old(::dmi::ComponentAlarmState value) {
+
+ old_ = value;
+ // @@protoc_insertion_point(field_set:dmi.AlarmStateChange.old)
+}
+
+// .dmi.ComponentAlarmState new = 2;
+inline void AlarmStateChange::clear_new_() {
+ new__ = 0;
+}
+inline ::dmi::ComponentAlarmState AlarmStateChange::new_() const {
+ // @@protoc_insertion_point(field_get:dmi.AlarmStateChange.new)
+ return static_cast< ::dmi::ComponentAlarmState >(new__);
+}
+inline void AlarmStateChange::set_new_(::dmi::ComponentAlarmState value) {
+
+ new__ = value;
+ // @@protoc_insertion_point(field_set:dmi.AlarmStateChange.new)
+}
+
+// -------------------------------------------------------------------
+
+// UsageStateChange
+
+// .dmi.ComponentUsageState old = 1;
+inline void UsageStateChange::clear_old() {
+ old_ = 0;
+}
+inline ::dmi::ComponentUsageState UsageStateChange::old() const {
+ // @@protoc_insertion_point(field_get:dmi.UsageStateChange.old)
+ return static_cast< ::dmi::ComponentUsageState >(old_);
+}
+inline void UsageStateChange::set_old(::dmi::ComponentUsageState value) {
+
+ old_ = value;
+ // @@protoc_insertion_point(field_set:dmi.UsageStateChange.old)
+}
+
+// .dmi.ComponentUsageState new = 2;
+inline void UsageStateChange::clear_new_() {
+ new__ = 0;
+}
+inline ::dmi::ComponentUsageState UsageStateChange::new_() const {
+ // @@protoc_insertion_point(field_get:dmi.UsageStateChange.new)
+ return static_cast< ::dmi::ComponentUsageState >(new__);
+}
+inline void UsageStateChange::set_new_(::dmi::ComponentUsageState value) {
+
+ new__ = value;
+ // @@protoc_insertion_point(field_set:dmi.UsageStateChange.new)
+}
+
+// -------------------------------------------------------------------
+
+// StandbyStateChange
+
+// .dmi.ComponentStandbyState old = 1;
+inline void StandbyStateChange::clear_old() {
+ old_ = 0;
+}
+inline ::dmi::ComponentStandbyState StandbyStateChange::old() const {
+ // @@protoc_insertion_point(field_get:dmi.StandbyStateChange.old)
+ return static_cast< ::dmi::ComponentStandbyState >(old_);
+}
+inline void StandbyStateChange::set_old(::dmi::ComponentStandbyState value) {
+
+ old_ = value;
+ // @@protoc_insertion_point(field_set:dmi.StandbyStateChange.old)
+}
+
+// .dmi.ComponentStandbyState new = 2;
+inline void StandbyStateChange::clear_new_() {
+ new__ = 0;
+}
+inline ::dmi::ComponentStandbyState StandbyStateChange::new_() const {
+ // @@protoc_insertion_point(field_get:dmi.StandbyStateChange.new)
+ return static_cast< ::dmi::ComponentStandbyState >(new__);
+}
+inline void StandbyStateChange::set_new_(::dmi::ComponentStandbyState value) {
+
+ new__ = value;
+ // @@protoc_insertion_point(field_set:dmi.StandbyStateChange.new)
+}
+
+// -------------------------------------------------------------------
+
+// StateChangeInfo
+
+// .dmi.AdminStateChange admin_state_change = 1;
+inline bool StateChangeInfo::has_admin_state_change() const {
+ return state_change_case() == kAdminStateChange;
+}
+inline void StateChangeInfo::set_has_admin_state_change() {
+ _oneof_case_[0] = kAdminStateChange;
+}
+inline void StateChangeInfo::clear_admin_state_change() {
+ if (has_admin_state_change()) {
+ delete state_change_.admin_state_change_;
+ clear_has_state_change();
+ }
+}
+inline ::dmi::AdminStateChange* StateChangeInfo::release_admin_state_change() {
+ // @@protoc_insertion_point(field_release:dmi.StateChangeInfo.admin_state_change)
+ if (has_admin_state_change()) {
+ clear_has_state_change();
+ ::dmi::AdminStateChange* temp = state_change_.admin_state_change_;
+ state_change_.admin_state_change_ = nullptr;
+ return temp;
+ } else {
+ return nullptr;
+ }
+}
+inline const ::dmi::AdminStateChange& StateChangeInfo::admin_state_change() const {
+ // @@protoc_insertion_point(field_get:dmi.StateChangeInfo.admin_state_change)
+ return has_admin_state_change()
+ ? *state_change_.admin_state_change_
+ : *reinterpret_cast< ::dmi::AdminStateChange*>(&::dmi::_AdminStateChange_default_instance_);
+}
+inline ::dmi::AdminStateChange* StateChangeInfo::mutable_admin_state_change() {
+ if (!has_admin_state_change()) {
+ clear_state_change();
+ set_has_admin_state_change();
+ state_change_.admin_state_change_ = CreateMaybeMessage< ::dmi::AdminStateChange >(
+ GetArenaNoVirtual());
+ }
+ // @@protoc_insertion_point(field_mutable:dmi.StateChangeInfo.admin_state_change)
+ return state_change_.admin_state_change_;
+}
+
+// .dmi.OperStateChange oper_state_change = 2;
+inline bool StateChangeInfo::has_oper_state_change() const {
+ return state_change_case() == kOperStateChange;
+}
+inline void StateChangeInfo::set_has_oper_state_change() {
+ _oneof_case_[0] = kOperStateChange;
+}
+inline void StateChangeInfo::clear_oper_state_change() {
+ if (has_oper_state_change()) {
+ delete state_change_.oper_state_change_;
+ clear_has_state_change();
+ }
+}
+inline ::dmi::OperStateChange* StateChangeInfo::release_oper_state_change() {
+ // @@protoc_insertion_point(field_release:dmi.StateChangeInfo.oper_state_change)
+ if (has_oper_state_change()) {
+ clear_has_state_change();
+ ::dmi::OperStateChange* temp = state_change_.oper_state_change_;
+ state_change_.oper_state_change_ = nullptr;
+ return temp;
+ } else {
+ return nullptr;
+ }
+}
+inline const ::dmi::OperStateChange& StateChangeInfo::oper_state_change() const {
+ // @@protoc_insertion_point(field_get:dmi.StateChangeInfo.oper_state_change)
+ return has_oper_state_change()
+ ? *state_change_.oper_state_change_
+ : *reinterpret_cast< ::dmi::OperStateChange*>(&::dmi::_OperStateChange_default_instance_);
+}
+inline ::dmi::OperStateChange* StateChangeInfo::mutable_oper_state_change() {
+ if (!has_oper_state_change()) {
+ clear_state_change();
+ set_has_oper_state_change();
+ state_change_.oper_state_change_ = CreateMaybeMessage< ::dmi::OperStateChange >(
+ GetArenaNoVirtual());
+ }
+ // @@protoc_insertion_point(field_mutable:dmi.StateChangeInfo.oper_state_change)
+ return state_change_.oper_state_change_;
+}
+
+// .dmi.AlarmStateChange alarm_state_change = 3;
+inline bool StateChangeInfo::has_alarm_state_change() const {
+ return state_change_case() == kAlarmStateChange;
+}
+inline void StateChangeInfo::set_has_alarm_state_change() {
+ _oneof_case_[0] = kAlarmStateChange;
+}
+inline void StateChangeInfo::clear_alarm_state_change() {
+ if (has_alarm_state_change()) {
+ delete state_change_.alarm_state_change_;
+ clear_has_state_change();
+ }
+}
+inline ::dmi::AlarmStateChange* StateChangeInfo::release_alarm_state_change() {
+ // @@protoc_insertion_point(field_release:dmi.StateChangeInfo.alarm_state_change)
+ if (has_alarm_state_change()) {
+ clear_has_state_change();
+ ::dmi::AlarmStateChange* temp = state_change_.alarm_state_change_;
+ state_change_.alarm_state_change_ = nullptr;
+ return temp;
+ } else {
+ return nullptr;
+ }
+}
+inline const ::dmi::AlarmStateChange& StateChangeInfo::alarm_state_change() const {
+ // @@protoc_insertion_point(field_get:dmi.StateChangeInfo.alarm_state_change)
+ return has_alarm_state_change()
+ ? *state_change_.alarm_state_change_
+ : *reinterpret_cast< ::dmi::AlarmStateChange*>(&::dmi::_AlarmStateChange_default_instance_);
+}
+inline ::dmi::AlarmStateChange* StateChangeInfo::mutable_alarm_state_change() {
+ if (!has_alarm_state_change()) {
+ clear_state_change();
+ set_has_alarm_state_change();
+ state_change_.alarm_state_change_ = CreateMaybeMessage< ::dmi::AlarmStateChange >(
+ GetArenaNoVirtual());
+ }
+ // @@protoc_insertion_point(field_mutable:dmi.StateChangeInfo.alarm_state_change)
+ return state_change_.alarm_state_change_;
+}
+
+// .dmi.UsageStateChange usage_state_change = 4;
+inline bool StateChangeInfo::has_usage_state_change() const {
+ return state_change_case() == kUsageStateChange;
+}
+inline void StateChangeInfo::set_has_usage_state_change() {
+ _oneof_case_[0] = kUsageStateChange;
+}
+inline void StateChangeInfo::clear_usage_state_change() {
+ if (has_usage_state_change()) {
+ delete state_change_.usage_state_change_;
+ clear_has_state_change();
+ }
+}
+inline ::dmi::UsageStateChange* StateChangeInfo::release_usage_state_change() {
+ // @@protoc_insertion_point(field_release:dmi.StateChangeInfo.usage_state_change)
+ if (has_usage_state_change()) {
+ clear_has_state_change();
+ ::dmi::UsageStateChange* temp = state_change_.usage_state_change_;
+ state_change_.usage_state_change_ = nullptr;
+ return temp;
+ } else {
+ return nullptr;
+ }
+}
+inline const ::dmi::UsageStateChange& StateChangeInfo::usage_state_change() const {
+ // @@protoc_insertion_point(field_get:dmi.StateChangeInfo.usage_state_change)
+ return has_usage_state_change()
+ ? *state_change_.usage_state_change_
+ : *reinterpret_cast< ::dmi::UsageStateChange*>(&::dmi::_UsageStateChange_default_instance_);
+}
+inline ::dmi::UsageStateChange* StateChangeInfo::mutable_usage_state_change() {
+ if (!has_usage_state_change()) {
+ clear_state_change();
+ set_has_usage_state_change();
+ state_change_.usage_state_change_ = CreateMaybeMessage< ::dmi::UsageStateChange >(
+ GetArenaNoVirtual());
+ }
+ // @@protoc_insertion_point(field_mutable:dmi.StateChangeInfo.usage_state_change)
+ return state_change_.usage_state_change_;
+}
+
+// .dmi.StandbyStateChange standby_state_change = 5;
+inline bool StateChangeInfo::has_standby_state_change() const {
+ return state_change_case() == kStandbyStateChange;
+}
+inline void StateChangeInfo::set_has_standby_state_change() {
+ _oneof_case_[0] = kStandbyStateChange;
+}
+inline void StateChangeInfo::clear_standby_state_change() {
+ if (has_standby_state_change()) {
+ delete state_change_.standby_state_change_;
+ clear_has_state_change();
+ }
+}
+inline ::dmi::StandbyStateChange* StateChangeInfo::release_standby_state_change() {
+ // @@protoc_insertion_point(field_release:dmi.StateChangeInfo.standby_state_change)
+ if (has_standby_state_change()) {
+ clear_has_state_change();
+ ::dmi::StandbyStateChange* temp = state_change_.standby_state_change_;
+ state_change_.standby_state_change_ = nullptr;
+ return temp;
+ } else {
+ return nullptr;
+ }
+}
+inline const ::dmi::StandbyStateChange& StateChangeInfo::standby_state_change() const {
+ // @@protoc_insertion_point(field_get:dmi.StateChangeInfo.standby_state_change)
+ return has_standby_state_change()
+ ? *state_change_.standby_state_change_
+ : *reinterpret_cast< ::dmi::StandbyStateChange*>(&::dmi::_StandbyStateChange_default_instance_);
+}
+inline ::dmi::StandbyStateChange* StateChangeInfo::mutable_standby_state_change() {
+ if (!has_standby_state_change()) {
+ clear_state_change();
+ set_has_standby_state_change();
+ state_change_.standby_state_change_ = CreateMaybeMessage< ::dmi::StandbyStateChange >(
+ GetArenaNoVirtual());
+ }
+ // @@protoc_insertion_point(field_mutable:dmi.StateChangeInfo.standby_state_change)
+ return state_change_.standby_state_change_;
+}
+
+inline bool StateChangeInfo::has_state_change() const {
+ return state_change_case() != STATE_CHANGE_NOT_SET;
+}
+inline void StateChangeInfo::clear_has_state_change() {
+ _oneof_case_[0] = STATE_CHANGE_NOT_SET;
+}
+inline StateChangeInfo::StateChangeCase StateChangeInfo::state_change_case() const {
+ return StateChangeInfo::StateChangeCase(_oneof_case_[0]);
+}
+// -------------------------------------------------------------------
+
// Event
// .dmi.EventMetaData event_metadata = 1;
@@ -3133,6 +4324,57 @@
// @@protoc_insertion_point(field_set_allocated:dmi.Event.add_info)
}
+// .dmi.StateChangeInfo state_change_info = 6;
+inline bool Event::has_state_change_info() const {
+ return this != internal_default_instance() && state_change_info_ != nullptr;
+}
+inline void Event::clear_state_change_info() {
+ if (GetArenaNoVirtual() == nullptr && state_change_info_ != nullptr) {
+ delete state_change_info_;
+ }
+ state_change_info_ = nullptr;
+}
+inline const ::dmi::StateChangeInfo& Event::state_change_info() const {
+ const ::dmi::StateChangeInfo* p = state_change_info_;
+ // @@protoc_insertion_point(field_get:dmi.Event.state_change_info)
+ return p != nullptr ? *p : *reinterpret_cast<const ::dmi::StateChangeInfo*>(
+ &::dmi::_StateChangeInfo_default_instance_);
+}
+inline ::dmi::StateChangeInfo* Event::release_state_change_info() {
+ // @@protoc_insertion_point(field_release:dmi.Event.state_change_info)
+
+ ::dmi::StateChangeInfo* temp = state_change_info_;
+ state_change_info_ = nullptr;
+ return temp;
+}
+inline ::dmi::StateChangeInfo* Event::mutable_state_change_info() {
+
+ if (state_change_info_ == nullptr) {
+ auto* p = CreateMaybeMessage<::dmi::StateChangeInfo>(GetArenaNoVirtual());
+ state_change_info_ = p;
+ }
+ // @@protoc_insertion_point(field_mutable:dmi.Event.state_change_info)
+ return state_change_info_;
+}
+inline void Event::set_allocated_state_change_info(::dmi::StateChangeInfo* state_change_info) {
+ ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+ if (message_arena == nullptr) {
+ delete state_change_info_;
+ }
+ if (state_change_info) {
+ ::google::protobuf::Arena* submessage_arena = nullptr;
+ if (message_arena != submessage_arena) {
+ state_change_info = ::google::protobuf::internal::GetOwnedMessage(
+ message_arena, state_change_info, submessage_arena);
+ }
+
+ } else {
+
+ }
+ state_change_info_ = state_change_info;
+ // @@protoc_insertion_point(field_set_allocated:dmi.Event.state_change_info)
+}
+
#ifdef __GNUC__
#pragma GCC diagnostic pop
#endif // __GNUC__
@@ -3156,6 +4398,18 @@
// -------------------------------------------------------------------
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
// @@protoc_insertion_point(namespace_scope)