Refactor the threshold checking code
Use threshold template classes so the same code can be used to check
each type of threshold.
Signed-off-by: Matt Spinler <spinler@us.ibm.com>
Change-Id: I04dfed24a60b30254b9f2dbb26c5cb048a03ab5a
diff --git a/thresholds.hpp b/thresholds.hpp
new file mode 100644
index 0000000..31c30e8
--- /dev/null
+++ b/thresholds.hpp
@@ -0,0 +1,190 @@
+#pragma once
+
+#include <xyz/openbmc_project/Sensor/Threshold/Critical/server.hpp>
+#include <xyz/openbmc_project/Sensor/Threshold/HardShutdown/server.hpp>
+#include <xyz/openbmc_project/Sensor/Threshold/SoftShutdown/server.hpp>
+#include <xyz/openbmc_project/Sensor/Threshold/Warning/server.hpp>
+
+namespace phosphor::virtualSensor
+{
+
+template <typename... T>
+using ServerObject = typename sdbusplus::server::object::object<T...>;
+
+using CriticalIface =
+ sdbusplus::xyz::openbmc_project::Sensor::Threshold::server::Critical;
+using CriticalObject = ServerObject<CriticalIface>;
+
+using WarningIface =
+ sdbusplus::xyz::openbmc_project::Sensor::Threshold::server::Warning;
+using WarningObject = ServerObject<WarningIface>;
+
+using SoftShutdownIface =
+ sdbusplus::xyz::openbmc_project::Sensor::Threshold::server::SoftShutdown;
+using SoftShutdownObject = ServerObject<SoftShutdownIface>;
+
+using HardShutdownIface =
+ sdbusplus::xyz::openbmc_project::Sensor::Threshold::server::HardShutdown;
+using HardShutdownObject = ServerObject<HardShutdownIface>;
+
+template <typename T>
+struct Threshold
+{};
+
+template <>
+struct Threshold<WarningObject>
+{
+ public:
+ static double high(WarningObject* iface)
+ {
+ return iface->warningHigh();
+ }
+ static double low(WarningObject* iface)
+ {
+ return iface->warningLow();
+ }
+
+ static bool alarmHigh(WarningObject* iface)
+ {
+ return iface->warningAlarmHigh();
+ }
+
+ static bool alarmLow(WarningObject* iface)
+ {
+ return iface->warningAlarmLow();
+ }
+
+ static void alarmHigh(WarningObject* iface, bool value)
+ {
+ iface->warningAlarmHigh(value);
+ }
+
+ static void alarmLow(WarningObject* iface, bool value)
+ {
+ iface->warningAlarmLow(value);
+ }
+
+ static const char* name()
+ {
+ return "Warning";
+ }
+};
+
+template <>
+struct Threshold<CriticalObject>
+{
+ public:
+ static double high(CriticalObject* iface)
+ {
+ return iface->criticalHigh();
+ }
+ static double low(CriticalObject* iface)
+ {
+ return iface->criticalLow();
+ }
+
+ static bool alarmHigh(CriticalObject* iface)
+ {
+ return iface->criticalAlarmHigh();
+ }
+
+ static bool alarmLow(CriticalObject* iface)
+ {
+ return iface->criticalAlarmLow();
+ }
+
+ static void alarmHigh(CriticalObject* iface, bool value)
+ {
+ iface->criticalAlarmHigh(value);
+ }
+
+ static void alarmLow(CriticalObject* iface, bool value)
+ {
+ iface->criticalAlarmLow(value);
+ }
+
+ static const char* name()
+ {
+ return "Critical";
+ }
+};
+
+template <>
+struct Threshold<SoftShutdownObject>
+{
+ public:
+ static double high(SoftShutdownObject* iface)
+ {
+ return iface->softShutdownHigh();
+ }
+ static double low(SoftShutdownObject* iface)
+ {
+ return iface->softShutdownLow();
+ }
+
+ static bool alarmHigh(SoftShutdownObject* iface)
+ {
+ return iface->softShutdownAlarmHigh();
+ }
+
+ static bool alarmLow(SoftShutdownObject* iface)
+ {
+ return iface->softShutdownAlarmLow();
+ }
+
+ static void alarmHigh(SoftShutdownObject* iface, bool value)
+ {
+ iface->softShutdownAlarmHigh(value);
+ }
+
+ static void alarmLow(SoftShutdownObject* iface, bool value)
+ {
+ iface->softShutdownAlarmLow(value);
+ }
+
+ static const char* name()
+ {
+ return "SoftShutdown";
+ }
+};
+
+template <>
+struct Threshold<HardShutdownObject>
+{
+ public:
+ static double high(HardShutdownObject* iface)
+ {
+ return iface->hardShutdownHigh();
+ }
+ static double low(HardShutdownObject* iface)
+ {
+ return iface->hardShutdownLow();
+ }
+
+ static bool alarmHigh(HardShutdownObject* iface)
+ {
+ return iface->hardShutdownAlarmHigh();
+ }
+
+ static bool alarmLow(HardShutdownObject* iface)
+ {
+ return iface->hardShutdownAlarmLow();
+ }
+
+ static void alarmHigh(HardShutdownObject* iface, bool value)
+ {
+ iface->hardShutdownAlarmHigh(value);
+ }
+
+ static void alarmLow(HardShutdownObject* iface, bool value)
+ {
+ iface->hardShutdownAlarmLow(value);
+ }
+
+ static const char* name()
+ {
+ return "HardShutdown";
+ }
+};
+
+} // namespace phosphor::virtualSensor