diff --git a/thresholds.hpp b/thresholds.hpp
index 31c30e8..e53e496 100644
--- a/thresholds.hpp
+++ b/thresholds.hpp
@@ -11,179 +11,125 @@
 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>;
+namespace threshold_ns =
+    sdbusplus::xyz::openbmc_project::Sensor::Threshold::server;
+using CriticalObject = ServerObject<threshold_ns::Critical>;
+using WarningObject = ServerObject<threshold_ns::Warning>;
+using SoftShutdownObject = ServerObject<threshold_ns::SoftShutdown>;
+using HardShutdownObject = ServerObject<threshold_ns::HardShutdown>;
 
 template <typename T>
-struct Threshold
-{};
+struct Threshold;
 
 template <>
-struct Threshold<WarningObject>
+struct Threshold<WarningObject> : public WarningObject
 {
-  public:
-    static double high(WarningObject* iface)
+    static constexpr auto name = "Warning";
+    using WarningObject::WarningObject;
+
+    auto high()
     {
-        return iface->warningHigh();
+        return warningHigh();
     }
-    static double low(WarningObject* iface)
+    auto low()
     {
-        return iface->warningLow();
+        return warningLow();
     }
 
-    static bool alarmHigh(WarningObject* iface)
+    template <typename... Args>
+    auto alarmHigh(Args... args)
     {
-        return iface->warningAlarmHigh();
+        return warningAlarmHigh(std::forward<Args>(args)...);
     }
 
-    static bool alarmLow(WarningObject* iface)
+    template <typename... Args>
+    auto alarmLow(Args... args)
     {
-        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";
+        return warningAlarmLow(std::forward<Args>(args)...);
     }
 };
 
 template <>
-struct Threshold<CriticalObject>
+struct Threshold<CriticalObject> : public CriticalObject
 {
-  public:
-    static double high(CriticalObject* iface)
+    static constexpr auto name = "Critical";
+    using CriticalObject::CriticalObject;
+
+    auto high()
     {
-        return iface->criticalHigh();
+        return criticalHigh();
     }
-    static double low(CriticalObject* iface)
+    auto low()
     {
-        return iface->criticalLow();
+        return criticalLow();
     }
 
-    static bool alarmHigh(CriticalObject* iface)
+    template <typename... Args>
+    auto alarmHigh(Args... args)
     {
-        return iface->criticalAlarmHigh();
+        return criticalAlarmHigh(std::forward<Args>(args)...);
     }
 
-    static bool alarmLow(CriticalObject* iface)
+    template <typename... Args>
+    auto alarmLow(Args... args)
     {
-        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";
+        return criticalAlarmLow(std::forward<Args>(args)...);
     }
 };
 
 template <>
-struct Threshold<SoftShutdownObject>
+struct Threshold<SoftShutdownObject> : public SoftShutdownObject
 {
-  public:
-    static double high(SoftShutdownObject* iface)
+    static constexpr auto name = "SoftShutdown";
+    using SoftShutdownObject::SoftShutdownObject;
+
+    auto high()
     {
-        return iface->softShutdownHigh();
+        return softShutdownHigh();
     }
-    static double low(SoftShutdownObject* iface)
+    auto low()
     {
-        return iface->softShutdownLow();
+        return softShutdownLow();
     }
 
-    static bool alarmHigh(SoftShutdownObject* iface)
+    template <typename... Args>
+    auto alarmHigh(Args... args)
     {
-        return iface->softShutdownAlarmHigh();
+        return softShutdownAlarmHigh(std::forward<Args>(args)...);
     }
 
-    static bool alarmLow(SoftShutdownObject* iface)
+    template <typename... Args>
+    auto alarmLow(Args... args)
     {
-        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";
+        return softShutdownAlarmLow(std::forward<Args>(args)...);
     }
 };
 
 template <>
-struct Threshold<HardShutdownObject>
+struct Threshold<HardShutdownObject> : public HardShutdownObject
 {
-  public:
-    static double high(HardShutdownObject* iface)
+    static constexpr auto name = "HardShutdown";
+    using HardShutdownObject::HardShutdownObject;
+
+    auto high()
     {
-        return iface->hardShutdownHigh();
+        return hardShutdownHigh();
     }
-    static double low(HardShutdownObject* iface)
+    auto low()
     {
-        return iface->hardShutdownLow();
+        return hardShutdownLow();
     }
 
-    static bool alarmHigh(HardShutdownObject* iface)
+    template <typename... Args>
+    auto alarmHigh(Args... args)
     {
-        return iface->hardShutdownAlarmHigh();
+        return hardShutdownAlarmHigh(std::forward<Args>(args)...);
     }
 
-    static bool alarmLow(HardShutdownObject* iface)
+    template <typename... Args>
+    auto alarmLow(Args... args)
     {
-        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";
+        return hardShutdownAlarmLow(std::forward<Args>(args)...);
     }
 };
 
diff --git a/virtualSensor.cpp b/virtualSensor.cpp
index 74b04f7..a67077b 100644
--- a/virtualSensor.cpp
+++ b/virtualSensor.cpp
@@ -88,8 +88,8 @@
         if (threshold.contains("CriticalHigh") ||
             threshold.contains("CriticalLow"))
         {
-            criticalIface =
-                std::make_unique<CriticalObject>(bus, objPath.c_str());
+            criticalIface = std::make_unique<Threshold<CriticalObject>>(
+                bus, objPath.c_str());
 
             criticalIface->criticalHigh(threshold.value(
                 "CriticalHigh", std::numeric_limits<double>::quiet_NaN()));
@@ -100,8 +100,8 @@
         if (threshold.contains("WarningHigh") ||
             threshold.contains("WarningLow"))
         {
-            warningIface =
-                std::make_unique<WarningObject>(bus, objPath.c_str());
+            warningIface = std::make_unique<Threshold<WarningObject>>(
+                bus, objPath.c_str());
 
             warningIface->warningHigh(threshold.value(
                 "WarningHigh", std::numeric_limits<double>::quiet_NaN()));
@@ -112,8 +112,8 @@
         if (threshold.contains("HardShutdownHigh") ||
             threshold.contains("HardShutdownLow"))
         {
-            hardShutdownIface =
-                std::make_unique<HardShutdownObject>(bus, objPath.c_str());
+            hardShutdownIface = std::make_unique<Threshold<HardShutdownObject>>(
+                bus, objPath.c_str());
 
             hardShutdownIface->hardShutdownHigh(threshold.value(
                 "HardShutdownHigh", std::numeric_limits<double>::quiet_NaN()));
@@ -124,8 +124,8 @@
         if (threshold.contains("SoftShutdownHigh") ||
             threshold.contains("SoftShutdownLow"))
         {
-            softShutdownIface =
-                std::make_unique<SoftShutdownObject>(bus, objPath.c_str());
+            softShutdownIface = std::make_unique<Threshold<SoftShutdownObject>>(
+                bus, objPath.c_str());
 
             softShutdownIface->softShutdownHigh(threshold.value(
                 "SoftShutdownHigh", std::numeric_limits<double>::quiet_NaN()));
@@ -248,10 +248,10 @@
         std::cout << "Sensor value is " << val << "\n";
 
     /* Check sensor thresholds and log required message */
-    checkThresholds(val, warningIface.get());
-    checkThresholds(val, criticalIface.get());
-    checkThresholds(val, softShutdownIface.get());
-    checkThresholds(val, hardShutdownIface.get());
+    checkThresholds(val, warningIface);
+    checkThresholds(val, criticalIface);
+    checkThresholds(val, softShutdownIface);
+    checkThresholds(val, hardShutdownIface);
 }
 
 /** @brief Parsing Virtual Sensor config JSON file  */
diff --git a/virtualSensor.hpp b/virtualSensor.hpp
index 13e342c..62042d8 100644
--- a/virtualSensor.hpp
+++ b/virtualSensor.hpp
@@ -108,13 +108,13 @@
     exprtk::rtl::vecops::package<double> vecopsPackage;
 
     /** @brief The critical threshold interface object */
-    std::unique_ptr<CriticalObject> criticalIface;
+    std::unique_ptr<Threshold<CriticalObject>> criticalIface;
     /** @brief The warning threshold interface object */
-    std::unique_ptr<WarningObject> warningIface;
+    std::unique_ptr<Threshold<WarningObject>> warningIface;
     /** @brief The soft shutdown threshold interface object */
-    std::unique_ptr<SoftShutdownObject> softShutdownIface;
+    std::unique_ptr<Threshold<SoftShutdownObject>> softShutdownIface;
     /** @brief The hard shutdown threshold interface object */
-    std::unique_ptr<HardShutdownObject> hardShutdownIface;
+    std::unique_ptr<Threshold<HardShutdownObject>> hardShutdownIface;
 
     /** @brief Read config from json object and initialize sensor data
      * for each virtual sensor
@@ -123,50 +123,47 @@
                            const std::string& objPath);
 
     /** @brief Check Sensor threshold and update alarm and log */
-    template <typename T>
-    void checkThresholds(double value, T* iface)
+    template <typename V, typename T>
+    void checkThresholds(V value, T& threshold)
     {
-        if (iface)
-        {
-            if (value >= Threshold<T>::high(iface))
-            {
-                if (!Threshold<T>::alarmHigh(iface))
-                {
-                    Threshold<T>::alarmHigh(iface, true);
-                    log<level::ERR>(fmt::format("ASSERT: {} has exceeded the "
-                                                "{} high threshold",
-                                                name, Threshold<T>::name())
-                                        .c_str());
-                }
-            }
-            else if (Threshold<T>::alarmHigh(iface))
-            {
-                Threshold<T>::alarmHigh(iface, false);
-                log<level::INFO>(fmt::format("DEASSERT: {} is under the "
-                                             "{} high threshold",
-                                             name, Threshold<T>::name())
-                                     .c_str());
-            }
+        if (!threshold)
+            return;
 
-            if (value <= Threshold<T>::low(iface))
+        static constexpr auto tname = T::element_type::name;
+
+        auto alarmHigh = threshold->alarmHigh();
+        if ((!alarmHigh && value >= threshold->high()) || alarmHigh)
+        {
+            if (!alarmHigh)
             {
-                if (!Threshold<T>::alarmLow(iface))
-                {
-                    Threshold<T>::alarmLow(iface, true);
-                    log<level::ERR>(fmt::format("ASSERT: {} is under the "
-                                                "{} high threshold",
-                                                name, Threshold<T>::name())
-                                        .c_str());
-                }
+                constexpr auto msg =
+                    "ASSERT: {} has exceeded the {} high threshold";
+                log<level::ERR>(fmt::format(msg, name, tname).c_str());
             }
-            else if (Threshold<T>::alarmLow(iface))
+            else
             {
-                Threshold<T>::alarmLow(iface, false);
-                log<level::INFO>(fmt::format("DEASSERT: {} is above the "
-                                             "{} high threshold",
-                                             name, Threshold<T>::name())
-                                     .c_str());
+                constexpr auto msg =
+                    "DEASSERT: {} is under the {} high threshold";
+                log<level::INFO>(fmt::format(msg, name, tname).c_str());
             }
+            threshold->alarmHigh(!alarmHigh);
+        }
+
+        auto alarmLow = threshold->alarmLow();
+        if ((!alarmLow && value <= threshold->low()) || alarmLow)
+        {
+            if (!alarmLow)
+            {
+                constexpr auto msg = "ASSERT: {} is under the {} low threshold";
+                log<level::ERR>(fmt::format(msg, name, tname).c_str());
+            }
+            else
+            {
+                constexpr auto msg =
+                    "DEASSERT: {} is above the {} low threshold";
+                log<level::INFO>(fmt::format(msg, name, tname).c_str());
+            }
+            threshold->alarmLow(!alarmLow);
         }
     }
 };