diff --git a/libpldmresponder/bios.cpp b/libpldmresponder/bios.cpp
index a246bb7..f9f3a55 100644
--- a/libpldmresponder/bios.cpp
+++ b/libpldmresponder/bios.cpp
@@ -21,6 +21,7 @@
 namespace fs = std::filesystem;
 using namespace pldm::responder::bios;
 using namespace bios_parser;
+using namespace pldm::utils;
 
 constexpr auto stringTableFile = "stringTable";
 constexpr auto attrTableFile = "attributeTable";
@@ -208,11 +209,12 @@
     uint64_t timeUsec = std::chrono::duration_cast<std::chrono::microseconds>(
                             std::chrono::seconds(timeSec))
                             .count();
-    std::variant<uint64_t> value{timeUsec};
+    PropertyValue value{timeUsec};
     try
     {
-        pldm::utils::DBusHandler().setDbusProperty(setTimePath, timeSetPro,
-                                                   setTimeInterface, value);
+        DBusMapping dbusMapping{setTimePath, setTimeInterface, timeSetPro,
+                                "uint64_t"};
+        pldm::utils::DBusHandler().setDbusProperty(dbusMapping, value);
     }
     catch (std::exception& e)
     {
diff --git a/libpldmresponder/bios_parser.cpp b/libpldmresponder/bios_parser.cpp
index 2dc2e57..0b74059 100644
--- a/libpldmresponder/bios_parser.cpp
+++ b/libpldmresponder/bios_parser.cpp
@@ -17,6 +17,7 @@
 namespace bios_parser
 {
 
+using namespace pldm::utils;
 using Json = nlohmann::json;
 namespace fs = std::filesystem;
 using namespace pldm::responder::bios;
@@ -24,21 +25,11 @@
 const std::vector<Json> emptyJsonList{};
 const Json emptyJson{};
 
-struct DBusMapping
-{
-    std::string objectPath;   //!< D-Bus object path
-    std::string interface;    //!< D-Bus interface
-    std::string propertyName; //!< D-Bus property name
-    std::string propertyType; //!< D-Bus property type
-};
-
 using AttrType = uint8_t;
 using Table = std::vector<uint8_t>;
 using BIOSJsonName = std::string;
 using AttrLookup = std::map<AttrName, std::optional<DBusMapping>>;
-using PropertyValue =
-    std::variant<bool, uint8_t, int16_t, uint16_t, int32_t, uint32_t, int64_t,
-                 uint64_t, double, std::string>;
+
 const std::set<std::string> SupportedDbusPropertyTypes = {
     "bool",     "uint8_t", "int16_t",  "uint16_t", "int32_t",
     "uint32_t", "int64_t", "uint64_t", "double",   "string"};
@@ -173,66 +164,6 @@
 
     return valueMap;
 }
-
-void updateDbusProperty(const DBusMapping& dBusMap, const PropertyValue& value)
-{
-    auto setDbusProperty = [&dBusMap](const auto& variant) {
-        pldm::utils::DBusHandler().setDbusProperty(
-            dBusMap.objectPath.c_str(), dBusMap.propertyName.c_str(),
-            dBusMap.interface.c_str(), variant);
-    };
-
-    if (dBusMap.propertyType == "uint8_t")
-    {
-        std::variant<uint8_t> v = std::get<uint8_t>(value);
-        setDbusProperty(v);
-    }
-    else if (dBusMap.propertyType == "int16_t")
-    {
-        std::variant<int16_t> v = std::get<int16_t>(value);
-        setDbusProperty(v);
-    }
-    else if (dBusMap.propertyType == "uint16_t")
-    {
-        std::variant<uint16_t> v = std::get<uint16_t>(value);
-        setDbusProperty(v);
-    }
-    else if (dBusMap.propertyType == "int32_t")
-    {
-        std::variant<int32_t> v = std::get<int32_t>(value);
-        setDbusProperty(v);
-    }
-    else if (dBusMap.propertyType == "uint32_t")
-    {
-        std::variant<uint32_t> v = std::get<uint32_t>(value);
-        setDbusProperty(v);
-    }
-    else if (dBusMap.propertyType == "int64_t")
-    {
-        std::variant<int64_t> v = std::get<int64_t>(value);
-        setDbusProperty(v);
-    }
-    else if (dBusMap.propertyType == "uint64_t")
-    {
-        std::variant<uint64_t> v = std::get<uint64_t>(value);
-        setDbusProperty(v);
-    }
-    else if (dBusMap.propertyType == "double")
-    {
-        std::variant<double> v = std::get<double>(value);
-        setDbusProperty(v);
-    }
-    else if (dBusMap.propertyType == "string")
-    {
-        std::variant<std::string> v = std::get<std::string>(value);
-        setDbusProperty(v);
-    }
-    else
-    {
-        assert(false && "UnSpported Dbus Type");
-    }
-}
-
 } // namespace internal
 
 int setupBIOSStrings(const Json& entry, Strings& strings)
@@ -352,7 +283,7 @@
         return PLDM_ERROR;
     }
 
-    internal::updateDbusProperty(dBusMap.value(), it->first);
+    pldm::utils::DBusHandler().setDbusProperty(dBusMap.value(), it->first);
 
     return PLDM_SUCCESS;
 }
@@ -503,12 +434,9 @@
     std::vector<uint8_t> data(currentString.ptr,
                               currentString.ptr + currentString.length);
 
-    std::variant<std::string> value =
+    PropertyValue value =
         stringToUtf8(static_cast<BIOSStringEncoding>(stringType), data);
-
-    pldm::utils::DBusHandler().setDbusProperty(
-        dBusMap->objectPath.c_str(), dBusMap->propertyName.c_str(),
-        dBusMap->interface.c_str(), value);
+    pldm::utils::DBusHandler().setDbusProperty(dBusMap.value(), value);
 
     return PLDM_SUCCESS;
 }
@@ -556,55 +484,6 @@
     return 0;
 }
 
-void updateDbusProperty(const DBusMapping& dBusMap, uint64_t value)
-{
-    auto setDbusProperty = [&dBusMap](const auto& variant) {
-        pldm::utils::DBusHandler().setDbusProperty(
-            dBusMap.objectPath.c_str(), dBusMap.propertyName.c_str(),
-            dBusMap.interface.c_str(), variant);
-    };
-
-    if (dBusMap.propertyType == "uint8_t")
-    {
-        std::variant<uint8_t> v = value;
-        setDbusProperty(v);
-    }
-    else if (dBusMap.propertyType == "int16_t")
-    {
-        std::variant<int16_t> v = value;
-        setDbusProperty(v);
-    }
-    else if (dBusMap.propertyType == "uint16_t")
-    {
-        std::variant<uint16_t> v = value;
-        setDbusProperty(v);
-    }
-    else if (dBusMap.propertyType == "int32_t")
-    {
-        std::variant<int32_t> v = value;
-        setDbusProperty(v);
-    }
-    else if (dBusMap.propertyType == "uint32_t")
-    {
-        std::variant<uint32_t> v = value;
-        setDbusProperty(v);
-    }
-    else if (dBusMap.propertyType == "int64_t")
-    {
-        std::variant<int64_t> v = value;
-        setDbusProperty(v);
-    }
-    else if (dBusMap.propertyType == "uint64_t")
-    {
-        std::variant<uint64_t> v = value;
-        setDbusProperty(v);
-    }
-    else
-    {
-        assert(false && "Unsupported Dbus Type");
-    }
-}
-
 const AttrValuesMap& getValues()
 {
     return valueMap;
@@ -639,7 +518,8 @@
     uint64_t currentValue =
         pldm_bios_table_attr_value_entry_integer_decode_cv(attrValueEntry);
 
-    updateDbusProperty(dBusMap.value(), currentValue);
+    PropertyValue value = static_cast<uint64_t>(currentValue);
+    pldm::utils::DBusHandler().setDbusProperty(dBusMap.value(), value);
 
     return PLDM_SUCCESS;
 }
diff --git a/libpldmresponder/platform.hpp b/libpldmresponder/platform.hpp
index 8bcc596..8c9e45c 100644
--- a/libpldmresponder/platform.hpp
+++ b/libpldmresponder/platform.hpp
@@ -102,6 +102,7 @@
         const std::vector<set_effecter_state_field>& stateField)
     {
         using namespace pldm::responder::pdr;
+        using namespace pldm::utils;
         using namespace std::string_literals;
         using DBusProperty = std::variant<std::string, bool>;
         using StateSetId = uint16_t;
@@ -181,23 +182,23 @@
                                    << "\n";
                          return PLDM_ERROR_INVALID_DATA;
                      }
-                     auto dbusProp = "OperatingSystemState";
-                     std::variant<std::string> value{
-                         std::get<std::string>(iter->second)};
-                     auto dbusInterface =
-                         "xyz.openbmc_project.State.OperatingSystem.Status";
+                     PropertyValue value{std::get<std::string>(iter->second)};
+                     DBusMapping dbusMapping{
+                         objPath,
+                         "xyz.openbmc_project.State.OperatingSystem.Status",
+                         "OperatingSystemState", "string"};
                      try
                      {
-                         dBusIntf.setDbusProperty(objPath.c_str(), dbusProp,
-                                                  dbusInterface, value);
+                         dBusIntf.setDbusProperty(dbusMapping, value);
                      }
                      catch (const std::exception& e)
                      {
                          std::cerr
                              << "Error setting property, ERROR=" << e.what()
-                             << " PROPERTY=" << dbusProp
-                             << " INTERFACE=" << dbusInterface
-                             << " PATH=" << objPath.c_str() << "\n";
+                             << " PROPERTY=" << dbusMapping.propertyName
+                             << " INTERFACE="
+                             << dbusMapping.interface << " PATH="
+                             << dbusMapping.objectPath << "\n";
                          return PLDM_ERROR;
                      }
                      return PLDM_SUCCESS;
@@ -226,22 +227,22 @@
                                    << "\n";
                          return PLDM_ERROR_INVALID_DATA;
                      }
-                     auto dbusProp = "RequestedPowerTransition";
-                     std::variant<std::string> value{
-                         std::get<std::string>(iter->second)};
-                     auto dbusInterface = "xyz.openbmc_project.State.Chassis";
+                     PropertyValue value{std::get<std::string>(iter->second)};
+                     DBusMapping dbusMapping{
+                         objPath, "xyz.openbmc_project.State.Chassis",
+                         "RequestedPowerTransition", "string"};
                      try
                      {
-                         dBusIntf.setDbusProperty(objPath.c_str(), dbusProp,
-                                                  dbusInterface, value);
+                         dBusIntf.setDbusProperty(dbusMapping, value);
                      }
                      catch (const std::exception& e)
                      {
                          std::cerr
                              << "Error setting property, ERROR=" << e.what()
-                             << " PROPERTY=" << dbusProp
-                             << " INTERFACE=" << dbusInterface
-                             << " PATH=" << objPath.c_str() << "\n";
+                             << " PROPERTY=" << dbusMapping.propertyName
+                             << " INTERFACE="
+                             << dbusMapping.interface << " PATH="
+                             << dbusMapping.objectPath << "\n";
                          return PLDM_ERROR;
                      }
                      return PLDM_SUCCESS;