diff --git a/host-bmc/dbus_to_event_handler.cpp b/host-bmc/dbus_to_event_handler.cpp
index 41826d0..9ad607e 100644
--- a/host-bmc/dbus_to_event_handler.cpp
+++ b/host-bmc/dbus_to_event_handler.cpp
@@ -21,17 +21,16 @@
 DbusToPLDMEvent::DbusToPLDMEvent(
     int /* mctp_fd */, uint8_t mctp_eid, pldm::InstanceIdDb& instanceIdDb,
     pldm::requester::Handler<pldm::requester::Request>* handler) :
-    mctp_eid(mctp_eid),
-    instanceIdDb(instanceIdDb), handler(handler)
+    mctp_eid(mctp_eid), instanceIdDb(instanceIdDb), handler(handler)
 {}
 
 void DbusToPLDMEvent::sendEventMsg(uint8_t eventType,
                                    const std::vector<uint8_t>& eventDataVec)
 {
     auto instanceId = instanceIdDb.next(mctp_eid);
-    std::vector<uint8_t> requestMsg(sizeof(pldm_msg_hdr) +
-                                    PLDM_PLATFORM_EVENT_MESSAGE_MIN_REQ_BYTES +
-                                    eventDataVec.size());
+    std::vector<uint8_t> requestMsg(
+        sizeof(pldm_msg_hdr) + PLDM_PLATFORM_EVENT_MESSAGE_MIN_REQ_BYTES +
+        eventDataVec.size());
     auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
 
     auto rc = encode_platform_event_message_req(
@@ -47,8 +46,9 @@
         return;
     }
 
-    auto platformEventMessageResponseHandler =
-        [](mctp_eid_t /*eid*/, const pldm_msg* response, size_t respMsgLen) {
+    auto platformEventMessageResponseHandler = [](mctp_eid_t /*eid*/,
+                                                  const pldm_msg* response,
+                                                  size_t respMsgLen) {
         if (response == nullptr || !respMsgLen)
         {
             error("Failed to receive response for platform event message");
@@ -113,62 +113,65 @@
                               dbusMapping.interface.c_str()),
             [this, sensorEventDataVec, dbusValueMapping, dbusMapping, sensorId,
              offset](auto& msg) mutable {
-            DbusChangedProps props{};
-            std::string intf;
-            uint8_t previousState = PLDM_SENSOR_UNKNOWN;
-            msg.read(intf, props);
-            if (!props.contains(dbusMapping.propertyName))
-            {
-                return;
-            }
-            for (const auto& itr : dbusValueMapping)
-            {
-                bool findValue = false;
-                if (dbusMapping.propertyType == "string")
+                DbusChangedProps props{};
+                std::string intf;
+                uint8_t previousState = PLDM_SENSOR_UNKNOWN;
+                msg.read(intf, props);
+                if (!props.contains(dbusMapping.propertyName))
                 {
-                    std::string src = std::get<std::string>(itr.second);
-                    std::string dst = std::get<std::string>(
-                        props.at(dbusMapping.propertyName));
-
-                    auto values = pldm::utils::split(src, "||", " ");
-                    for (const auto& value : values)
+                    return;
+                }
+                for (const auto& itr : dbusValueMapping)
+                {
+                    bool findValue = false;
+                    if (dbusMapping.propertyType == "string")
                     {
-                        if (value == dst)
+                        std::string src = std::get<std::string>(itr.second);
+                        std::string dst = std::get<std::string>(
+                            props.at(dbusMapping.propertyName));
+
+                        auto values = pldm::utils::split(src, "||", " ");
+                        for (const auto& value : values)
                         {
-                            findValue = true;
-                            break;
+                            if (value == dst)
+                            {
+                                findValue = true;
+                                break;
+                            }
                         }
                     }
-                }
-                else
-                {
-                    findValue = itr.second == props.at(dbusMapping.propertyName)
-                                    ? true
-                                    : false;
-                }
-
-                if (findValue)
-                {
-                    auto eventData =
-                        reinterpret_cast<struct pldm_sensor_event_data*>(
-                            sensorEventDataVec.data());
-                    eventData->event_class[1] = itr.first;
-                    if (sensorCacheMap.contains(sensorId) &&
-                        sensorCacheMap[sensorId][offset] != PLDM_SENSOR_UNKNOWN)
-                    {
-                        previousState = sensorCacheMap[sensorId][offset];
-                    }
                     else
                     {
-                        previousState = itr.first;
+                        findValue =
+                            itr.second == props.at(dbusMapping.propertyName)
+                                ? true
+                                : false;
                     }
-                    eventData->event_class[2] = previousState;
-                    this->sendEventMsg(PLDM_SENSOR_EVENT, sensorEventDataVec);
-                    updateSensorCacheMaps(sensorId, offset, previousState);
-                    break;
+
+                    if (findValue)
+                    {
+                        auto eventData =
+                            reinterpret_cast<struct pldm_sensor_event_data*>(
+                                sensorEventDataVec.data());
+                        eventData->event_class[1] = itr.first;
+                        if (sensorCacheMap.contains(sensorId) &&
+                            sensorCacheMap[sensorId][offset] !=
+                                PLDM_SENSOR_UNKNOWN)
+                        {
+                            previousState = sensorCacheMap[sensorId][offset];
+                        }
+                        else
+                        {
+                            previousState = itr.first;
+                        }
+                        eventData->event_class[2] = previousState;
+                        this->sendEventMsg(PLDM_SENSOR_EVENT,
+                                           sensorEventDataVec);
+                        updateSensorCacheMaps(sensorId, offset, previousState);
+                        break;
+                    }
                 }
-            }
-        });
+            });
         stateSensorMatchs.emplace_back(std::move(stateSensorMatch));
     }
 }
@@ -179,8 +182,8 @@
     const std::map<Type, sensorEvent> sensorHandlers = {
         {PLDM_STATE_SENSOR_PDR,
          [this](SensorId sensorId, const DbusObjMaps& dbusMaps) {
-        this->sendStateSensorEvent(sensorId, dbusMaps);
-    }}};
+             this->sendStateSensorEvent(sensorId, dbusMaps);
+         }}};
 
     pldm_state_sensor_pdr* pdr = nullptr;
     std::unique_ptr<pldm_pdr, decltype(&pldm_pdr_destroy)> sensorPdrRepo(
diff --git a/host-bmc/dbus_to_host_effecters.cpp b/host-bmc/dbus_to_host_effecters.cpp
index 0774685..9b1c250 100644
--- a/host-bmc/dbus_to_host_effecters.cpp
+++ b/host-bmc/dbus_to_host_effecters.cpp
@@ -68,12 +68,12 @@
         EffecterInfo effecterInfo;
         effecterInfo.mctpEid = entry.value("mctp_eid", 0xFF);
         auto jsonEffecterInfo = entry.value("effecter_info", empty);
-        auto effecterId = jsonEffecterInfo.value("effecterID",
-                                                 PLDM_INVALID_EFFECTER_ID);
+        auto effecterId =
+            jsonEffecterInfo.value("effecterID", PLDM_INVALID_EFFECTER_ID);
         effecterInfo.containerId = jsonEffecterInfo.value("containerID", 0);
         effecterInfo.entityType = jsonEffecterInfo.value("entityType", 0);
-        effecterInfo.entityInstance = jsonEffecterInfo.value("entityInstance",
-                                                             0);
+        effecterInfo.entityInstance =
+            jsonEffecterInfo.value("entityInstance", 0);
         effecterInfo.compEffecterCnt =
             jsonEffecterInfo.value("compositeEffecterCount", 0);
         auto effecters = entry.value("effecters", emptyList);
@@ -83,10 +83,10 @@
             auto jsonDbusInfo = effecter.value("dbus_info", empty);
             dbusInfo.dbusMap.objectPath = jsonDbusInfo.value("object_path", "");
             dbusInfo.dbusMap.interface = jsonDbusInfo.value("interface", "");
-            dbusInfo.dbusMap.propertyName = jsonDbusInfo.value("property_name",
-                                                               "");
-            dbusInfo.dbusMap.propertyType = jsonDbusInfo.value("property_type",
-                                                               "");
+            dbusInfo.dbusMap.propertyName =
+                jsonDbusInfo.value("property_name", "");
+            dbusInfo.dbusMap.propertyType =
+                jsonDbusInfo.value("property_type", "");
             Json propertyValues = jsonDbusInfo["property_values"];
 
             populatePropVals(propertyValues, dbusInfo.propertyValues,
@@ -192,8 +192,8 @@
     uint8_t newState{};
     try
     {
-        newState = findNewStateValue(effecterInfoIndex, dbusInfoIndex,
-                                     it->second);
+        newState =
+            findNewStateValue(effecterInfoIndex, dbusInfoIndex, it->second);
     }
     catch (const std::out_of_range& e)
     {
@@ -235,10 +235,9 @@
     }
 }
 
-uint8_t
-    HostEffecterParser::findNewStateValue(size_t effecterInfoIndex,
-                                          size_t dbusInfoIndex,
-                                          const PropertyValue& propertyValue)
+uint8_t HostEffecterParser::findNewStateValue(
+    size_t effecterInfoIndex, size_t dbusInfoIndex,
+    const PropertyValue& propertyValue)
 {
     const auto& propValues = hostEffecterInfo[effecterInfoIndex]
                                  .dbusInfo[dbusInfoIndex]
@@ -285,8 +284,9 @@
         return rc;
     }
 
-    auto setStateEffecterStatesRespHandler =
-        [](mctp_eid_t /*eid*/, const pldm_msg* response, size_t respMsgLen) {
+    auto setStateEffecterStatesRespHandler = [](mctp_eid_t /*eid*/,
+                                                const pldm_msg* response,
+                                                size_t respMsgLen) {
         if (response == nullptr || !respMsgLen)
         {
             error(
@@ -326,11 +326,9 @@
     return rc;
 }
 
-void HostEffecterParser::createHostEffecterMatch(const std::string& objectPath,
-                                                 const std::string& interface,
-                                                 size_t effecterInfoIndex,
-                                                 size_t dbusInfoIndex,
-                                                 uint16_t effecterId)
+void HostEffecterParser::createHostEffecterMatch(
+    const std::string& objectPath, const std::string& interface,
+    size_t effecterInfoIndex, size_t dbusInfoIndex, uint16_t effecterId)
 {
     using namespace sdbusplus::bus::match::rules;
     effecterInfoMatch.emplace_back(std::make_unique<sdbusplus::bus::match_t>(
@@ -338,12 +336,12 @@
         propertiesChanged(objectPath, interface),
         [this, effecterInfoIndex, dbusInfoIndex,
          effecterId](sdbusplus::message_t& msg) {
-        DbusChgHostEffecterProps props;
-        std::string iface;
-        msg.read(iface, props);
-        processHostEffecterChangeNotification(props, effecterInfoIndex,
-                                              dbusInfoIndex, effecterId);
-    }));
+            DbusChgHostEffecterProps props;
+            std::string iface;
+            msg.read(iface, props);
+            processHostEffecterChangeNotification(props, effecterInfoIndex,
+                                                  dbusInfoIndex, effecterId);
+        }));
 }
 
 } // namespace host_effecters
diff --git a/host-bmc/dbus_to_host_effecters.hpp b/host-bmc/dbus_to_host_effecters.hpp
index c06e8b0..7591381 100644
--- a/host-bmc/dbus_to_host_effecters.hpp
+++ b/host-bmc/dbus_to_host_effecters.hpp
@@ -86,8 +86,8 @@
         pldm::utils::DBusHandler* const dbusHandler,
         const std::string& jsonPath,
         pldm::requester::Handler<pldm::requester::Request>* handler) :
-        instanceIdDb(instanceIdDb),
-        sockFd(fd), pdrRepo(repo), dbusHandler(dbusHandler), handler(handler)
+        instanceIdDb(instanceIdDb), sockFd(fd), pdrRepo(repo),
+        dbusHandler(dbusHandler), handler(handler)
     {
         try
         {
@@ -141,10 +141,9 @@
      * @param[in] effecterId - host effecter id
      * @return - PLDM status code
      */
-    virtual int
-        setHostStateEffecter(size_t effecterInfoIndex,
-                             std::vector<set_effecter_state_field>& stateField,
-                             uint16_t effecterId);
+    virtual int setHostStateEffecter(
+        size_t effecterInfoIndex,
+        std::vector<set_effecter_state_field>& stateField, uint16_t effecterId);
 
     /* @brief Fetches the new state value and the index in stateField set which
      *        needs to be set with the new value in the setStateEffecter call
@@ -166,11 +165,9 @@
      * @param[in] dbusInfoIndex - index of dbusInfo within effecterInfo
      * @param[in] effecterId - host effecter id
      */
-    virtual void createHostEffecterMatch(const std::string& objectPath,
-                                         const std::string& interface,
-                                         size_t effecterInfoIndex,
-                                         size_t dbusInfoIndex,
-                                         uint16_t effecterId);
+    virtual void createHostEffecterMatch(
+        const std::string& objectPath, const std::string& interface,
+        size_t effecterInfoIndex, size_t dbusInfoIndex, uint16_t effecterId);
 
   protected:
     pldm::InstanceIdDb* instanceIdDb; //!< Reference to the InstanceIdDb object
diff --git a/host-bmc/host_condition.hpp b/host-bmc/host_condition.hpp
index f7d67fb..ad5a862 100644
--- a/host-bmc/host_condition.hpp
+++ b/host-bmc/host_condition.hpp
@@ -25,7 +25,7 @@
     virtual ~Host() = default;
 
     Host(sdbusplus::bus_t& bus, const std::string& path) :
-        HostIntf(bus, path.c_str()){};
+        HostIntf(bus, path.c_str()) {};
 
     /** @brief Override reads to CurrentFirmwareCondition */
     FirmwareCondition currentFirmwareCondition() const override;
diff --git a/host-bmc/host_pdr_handler.cpp b/host-bmc/host_pdr_handler.cpp
index ff50f94..4bcdb7c 100644
--- a/host-bmc/host_pdr_handler.cpp
+++ b/host-bmc/host_pdr_handler.cpp
@@ -74,8 +74,8 @@
     }
 
     pldm_entity entity{t->entity_type, t->entity_instance, t->container_id};
-    auto node = pldm_entity_association_tree_find_with_locality(entityTree,
-                                                                &entity, true);
+    auto node = pldm_entity_association_tree_find_with_locality(
+        entityTree, &entity, true);
     if (node)
     {
         pldm_entity e = pldm_entity_extract(node);
@@ -90,9 +90,9 @@
     pldm_entity_association_tree* bmcEntityTree,
     pldm::InstanceIdDb& instanceIdDb,
     pldm::requester::Handler<pldm::requester::Request>* handler) :
-    mctp_eid(mctp_eid),
-    event(event), repo(repo), stateSensorHandler(eventsJsonsDir),
-    entityTree(entityTree), instanceIdDb(instanceIdDb), handler(handler),
+    mctp_eid(mctp_eid), event(event), repo(repo),
+    stateSensorHandler(eventsJsonsDir), entityTree(entityTree),
+    instanceIdDb(instanceIdDb), handler(handler),
     entityMaps(parseEntityMap(ENTITY_MAP_JSON)), oemUtilsHandler(nullptr)
 {
     mergedHostParents = false;
@@ -101,31 +101,31 @@
         propertiesChanged("/xyz/openbmc_project/state/host0",
                           "xyz.openbmc_project.State.Host"),
         [this, repo, entityTree, bmcEntityTree](sdbusplus::message_t& msg) {
-        DbusChangedProps props{};
-        std::string intf;
-        msg.read(intf, props);
-        const auto itr = props.find("CurrentHostState");
-        if (itr != props.end())
-        {
-            PropertyValue value = itr->second;
-            auto propVal = std::get<std::string>(value);
-            if (propVal == "xyz.openbmc_project.State.Host.HostState.Off")
+            DbusChangedProps props{};
+            std::string intf;
+            msg.read(intf, props);
+            const auto itr = props.find("CurrentHostState");
+            if (itr != props.end())
             {
-                // Delete all the remote terminus information
-                std::erase_if(tlPDRInfo, [](const auto& item) {
-                    auto const& [key, value] = item;
-                    return key != TERMINUS_HANDLE;
-                });
-                pldm_pdr_remove_remote_pdrs(repo);
-                pldm_entity_association_tree_destroy_root(entityTree);
-                pldm_entity_association_tree_copy_root(bmcEntityTree,
-                                                       entityTree);
-                this->sensorMap.clear();
-                this->responseReceived = false;
-                this->mergedHostParents = false;
+                PropertyValue value = itr->second;
+                auto propVal = std::get<std::string>(value);
+                if (propVal == "xyz.openbmc_project.State.Host.HostState.Off")
+                {
+                    // Delete all the remote terminus information
+                    std::erase_if(tlPDRInfo, [](const auto& item) {
+                        const auto& [key, value] = item;
+                        return key != TERMINUS_HANDLE;
+                    });
+                    pldm_pdr_remove_remote_pdrs(repo);
+                    pldm_entity_association_tree_destroy_root(entityTree);
+                    pldm_entity_association_tree_copy_root(bmcEntityTree,
+                                                           entityTree);
+                    this->sensorMap.clear();
+                    this->responseReceived = false;
+                    this->mergedHostParents = false;
+                }
             }
-        }
-    });
+        });
 }
 
 void HostPDRHandler::fetchPDR(PDRRecordHandles&& recordHandles)
@@ -159,8 +159,8 @@
 {
     pdrFetchEvent.reset();
 
-    std::vector<uint8_t> requestMsg(sizeof(pldm_msg_hdr) +
-                                    PLDM_GET_PDR_REQ_BYTES);
+    std::vector<uint8_t> requestMsg(
+        sizeof(pldm_msg_hdr) + PLDM_GET_PDR_REQ_BYTES);
     auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
     uint32_t recordHandle{};
     if (!nextRecordHandle && (!modifiedPDRRecordHandles.empty()) &&
@@ -180,9 +180,9 @@
     }
     auto instanceId = instanceIdDb.next(mctp_eid);
 
-    auto rc = encode_get_pdr_req(instanceId, recordHandle, 0,
-                                 PLDM_GET_FIRSTPART, UINT16_MAX, 0, request,
-                                 PLDM_GET_PDR_REQ_BYTES);
+    auto rc =
+        encode_get_pdr_req(instanceId, recordHandle, 0, PLDM_GET_FIRSTPART,
+                           UINT16_MAX, 0, request, PLDM_GET_PDR_REQ_BYTES);
     if (rc != PLDM_SUCCESS)
     {
         instanceIdDb.free(mctp_eid, instanceId);
@@ -299,8 +299,8 @@
             {
                 auto record = oemPlatformHandler->fetchLastBMCRecord(repo);
 
-                uint32_t record_handle = pldm_pdr_get_record_handle(repo,
-                                                                    record);
+                uint32_t record_handle =
+                    pldm_pdr_get_record_handle(repo, record);
 
                 rc =
                     pldm_entity_association_pdr_add_from_node_with_record_handle(
@@ -377,9 +377,9 @@
         return;
     }
     auto instanceId = instanceIdDb.next(mctp_eid);
-    std::vector<uint8_t> requestMsg(sizeof(pldm_msg_hdr) +
-                                    PLDM_PLATFORM_EVENT_MESSAGE_MIN_REQ_BYTES +
-                                    actualSize);
+    std::vector<uint8_t> requestMsg(
+        sizeof(pldm_msg_hdr) + PLDM_PLATFORM_EVENT_MESSAGE_MIN_REQ_BYTES +
+        actualSize);
     auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
     rc = encode_platform_event_message_req(
         instanceId, 1, TERMINUS_ID, PLDM_PDR_REPOSITORY_CHG_EVENT,
@@ -394,8 +394,9 @@
         return;
     }
 
-    auto platformEventMessageResponseHandler =
-        [](mctp_eid_t /*eid*/, const pldm_msg* response, size_t respMsgLen) {
+    auto platformEventMessageResponseHandler = [](mctp_eid_t /*eid*/,
+                                                  const pldm_msg* response,
+                                                  size_t respMsgLen) {
         if (response == nullptr || !respMsgLen)
         {
             error(
@@ -449,9 +450,8 @@
     }
 }
 
-void HostPDRHandler::processHostPDRs(mctp_eid_t /*eid*/,
-                                     const pldm_msg* response,
-                                     size_t respMsgLen)
+void HostPDRHandler::processHostPDRs(
+    mctp_eid_t /*eid*/, const pldm_msg* response, size_t respMsgLen)
 {
     static bool merged = false;
     static PDRList stateSensorPDRs{};
@@ -704,8 +704,8 @@
 {
     responseReceived = false;
     auto instanceId = instanceIdDb.next(mctp_eid);
-    std::vector<uint8_t> requestMsg(sizeof(pldm_msg_hdr) +
-                                    PLDM_GET_VERSION_REQ_BYTES);
+    std::vector<uint8_t> requestMsg(
+        sizeof(pldm_msg_hdr) + PLDM_GET_VERSION_REQ_BYTES);
     auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
     auto rc = encode_get_version_req(instanceId, 0, PLDM_GET_FIRSTPART,
                                      PLDM_BASE, request);
@@ -795,9 +795,11 @@
                     return;
                 }
 
-                auto getStateSensorReadingRespHandler =
-                    [=, this](mctp_eid_t /*eid*/, const pldm_msg* response,
-                              size_t respMsgLen) {
+                auto getStateSensorReadingRespHandler = [=, this](
+                                                            mctp_eid_t /*eid*/,
+                                                            const pldm_msg*
+                                                                response,
+                                                            size_t respMsgLen) {
                     if (response == nullptr || !respMsgLen)
                     {
                         error(
@@ -884,8 +886,8 @@
                                 "STATE", eventState);
                             return;
                         }
-                        const auto& [containerId, entityType,
-                                     entityInstance] = entityInfo;
+                        const auto& [containerId, entityType, entityInstance] =
+                            entityInfo;
                         auto stateSetId = stateSetIds[sensorOffset];
                         pldm::responder::events::StateSensorEntry
                             stateSensorEntry{containerId,    entityType,
@@ -932,9 +934,11 @@
         return;
     }
 
-    auto getFruRecordTableMetadataResponseHandler =
-        [this, fruRecordSetPDRs](mctp_eid_t /*eid*/, const pldm_msg* response,
-                                 size_t respMsgLen) {
+    auto getFruRecordTableMetadataResponseHandler = [this, fruRecordSetPDRs](
+                                                        mctp_eid_t /*eid*/,
+                                                        const pldm_msg*
+                                                            response,
+                                                        size_t respMsgLen) {
         if (response == nullptr || !respMsgLen)
         {
             error(
@@ -992,8 +996,8 @@
     }
 
     auto instanceId = instanceIdDb.next(mctp_eid);
-    std::vector<uint8_t> requestMsg(sizeof(pldm_msg_hdr) +
-                                    PLDM_GET_FRU_RECORD_TABLE_REQ_BYTES);
+    std::vector<uint8_t> requestMsg(
+        sizeof(pldm_msg_hdr) + PLDM_GET_FRU_RECORD_TABLE_REQ_BYTES);
 
     // send the getFruRecordTable command
     auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
@@ -1009,9 +1013,11 @@
         return;
     }
 
-    auto getFruRecordTableResponseHandler =
-        [totalTableRecords, this, fruRecordSetPDRs](
-            mctp_eid_t /*eid*/, const pldm_msg* response, size_t respMsgLen) {
+    auto getFruRecordTableResponseHandler = [totalTableRecords, this,
+                                             fruRecordSetPDRs](
+                                                mctp_eid_t /*eid*/,
+                                                const pldm_msg* response,
+                                                size_t respMsgLen) {
         if (response == nullptr || !respMsgLen)
         {
             error("Failed to receive response for the get fru record table");
@@ -1022,8 +1028,8 @@
         uint32_t next_data_transfer_handle = 0;
         uint8_t transfer_flag = 0;
         size_t fru_record_table_length = 0;
-        std::vector<uint8_t> fru_record_table_data(respMsgLen -
-                                                   sizeof(pldm_msg_hdr));
+        std::vector<uint8_t> fru_record_table_data(
+            respMsgLen - sizeof(pldm_msg_hdr));
         auto responsePtr = reinterpret_cast<const struct pldm_msg*>(response);
         auto rc = decode_get_fru_record_table_resp(
             responsePtr, respMsgLen, &cc, &next_data_transfer_handle,
diff --git a/host-bmc/host_pdr_handler.hpp b/host-bmc/host_pdr_handler.hpp
index c75c172..6f3d008 100644
--- a/host-bmc/host_pdr_handler.hpp
+++ b/host-bmc/host_pdr_handler.hpp
@@ -206,10 +206,9 @@
      *  @param[in] size - size of input PDR record in bytes
      *  @param[in] record_handle - record handle of the PDR
      */
-    void
-        mergeEntityAssociations(const std::vector<uint8_t>& pdr,
-                                [[maybe_unused]] const uint32_t& size,
-                                [[maybe_unused]] const uint32_t& record_handle);
+    void mergeEntityAssociations(
+        const std::vector<uint8_t>& pdr, [[maybe_unused]] const uint32_t& size,
+        [[maybe_unused]] const uint32_t& record_handle);
 
     /** @brief process the Host's PDR and add to BMC's PDR repo
      *  @param[in] eid - MCTP id of Host
diff --git a/host-bmc/utils.cpp b/host-bmc/utils.cpp
index 648776d..41a5ec3 100644
--- a/host-bmc/utils.cpp
+++ b/host-bmc/utils.cpp
@@ -93,9 +93,10 @@
                 continue;
             }
 
-            fs::path p = path / fs::path{entityName +
-                                         std::to_string(
-                                             node_entity.entity_instance_num)};
+            fs::path p =
+                path /
+                fs::path{entityName +
+                         std::to_string(node_entity.entity_instance_num)};
             std::string entity_path = p.string();
             if (oemPlatformHandler)
             {
@@ -234,13 +235,13 @@
     char* err;
     try
     {
-        std::ranges::transform(entities.items(),
-                               std::inserter(entityMaps, entityMaps.begin()),
-                               [&err](const auto& element) {
-            std::string key = static_cast<EntityName>(element.key());
-            return std::make_pair(strtol(key.c_str(), &err, 10),
-                                  static_cast<EntityName>(element.value()));
-        });
+        std::ranges::transform(
+            entities.items(), std::inserter(entityMaps, entityMaps.begin()),
+            [&err](const auto& element) {
+                std::string key = static_cast<EntityName>(element.key());
+                return std::make_pair(strtol(key.c_str(), &err, 10),
+                                      static_cast<EntityName>(element.value()));
+            });
     }
     catch (const std::exception& e)
     {