diff --git a/.clang-format b/.clang-format
new file mode 100644
index 0000000..42a2307
--- /dev/null
+++ b/.clang-format
@@ -0,0 +1,99 @@
+---
+Language:        Cpp
+# BasedOnStyle:  LLVM
+AccessModifierOffset: -2
+AlignAfterOpenBracket: Align
+AlignConsecutiveAssignments: false
+AlignConsecutiveDeclarations: false
+AlignEscapedNewlinesLeft: false
+AlignOperands:   true
+AlignTrailingComments: true
+AllowAllParametersOfDeclarationOnNextLine: true
+AllowShortBlocksOnASingleLine: false
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: None
+AllowShortIfStatementsOnASingleLine: false
+AllowShortLoopsOnASingleLine: false
+AlwaysBreakAfterDefinitionReturnType: None
+AlwaysBreakAfterReturnType: None
+AlwaysBreakBeforeMultilineStrings: false
+AlwaysBreakTemplateDeclarations: true
+BinPackArguments: true
+BinPackParameters: true
+BraceWrapping:
+  AfterClass:      true
+  AfterControlStatement: true
+  AfterEnum:       true
+  AfterFunction:   true
+  AfterNamespace:  true
+  AfterObjCDeclaration: true
+  AfterStruct:     true
+  AfterUnion:      true
+  BeforeCatch:     true
+  BeforeElse:      true
+  IndentBraces:    false
+BreakBeforeBinaryOperators: None
+BreakBeforeBraces: Custom
+BreakBeforeTernaryOperators: true
+BreakConstructorInitializers: AfterColon
+ColumnLimit:     80
+CommentPragmas:  '^ IWYU pragma:'
+ConstructorInitializerAllOnOneLineOrOnePerLine: false
+ConstructorInitializerIndentWidth: 4
+ContinuationIndentWidth: 4
+Cpp11BracedListStyle: true
+DerivePointerAlignment: true
+PointerAlignment: Left
+DisableFormat:   false
+ExperimentalAutoDetectBinPacking: false
+FixNamespaceComments: true
+ForEachMacros:   [ foreach, Q_FOREACH, BOOST_FOREACH ]
+IncludeBlocks: Regroup
+IncludeCategories:
+  - Regex:           '^[<"](gtest|gmock)'
+    Priority:        5
+  - Regex:           '^"config.h"'
+    Priority:        -1
+  - Regex:           '^".*\.hpp"'
+    Priority:        1
+  - Regex:           '^<.*\.h>'
+    Priority:        2
+  - Regex:           '^<.*'
+    Priority:        3
+  - Regex:           '.*'
+    Priority:        4
+IndentCaseLabels: true
+IndentWidth:     4
+IndentWrappedFunctionNames: true
+KeepEmptyLinesAtTheStartOfBlocks: true
+MacroBlockBegin: ''
+MacroBlockEnd:   ''
+MaxEmptyLinesToKeep: 1
+NamespaceIndentation: None
+ObjCBlockIndentWidth: 2
+ObjCSpaceAfterProperty: false
+ObjCSpaceBeforeProtocolList: true
+PenaltyBreakBeforeFirstCallParameter: 19
+PenaltyBreakComment: 300
+PenaltyBreakFirstLessLess: 120
+PenaltyBreakString: 1000
+PenaltyExcessCharacter: 1000000
+PenaltyReturnTypeOnItsOwnLine: 60
+PointerAlignment: Right
+ReflowComments:  true
+SortIncludes:    true
+SpaceAfterCStyleCast: false
+SpaceBeforeAssignmentOperators: true
+SpaceBeforeParens: ControlStatements
+SpaceInEmptyParentheses: false
+SpacesBeforeTrailingComments: 1
+SpacesInAngles:  false
+SpacesInContainerLiterals: true
+SpacesInCStyleCastParentheses: false
+SpacesInParentheses: false
+SpacesInSquareBrackets: false
+Standard:        Cpp11
+TabWidth:        4
+UseTab:          Never
+...
+
diff --git a/argument.cpp b/argument.cpp
index 3849cae..99ee710 100644
--- a/argument.cpp
+++ b/argument.cpp
@@ -13,11 +13,12 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include <iostream>
-#include <iterator>
+#include "argument.hpp"
+
 #include <algorithm>
 #include <cassert>
-#include "argument.hpp"
+#include <iostream>
+#include <iterator>
 
 ArgumentParser::ArgumentParser(int argc, char** argv)
 {
@@ -66,13 +67,14 @@
     std::cerr << std::flush;
 }
 
-const option ArgumentParser::options[] =
-{
-    { "path",   required_argument,  NULL,   'p' },
-    { "dev-path", required_argument,  NULL, 'o' },
-    { "help",   no_argument,        NULL,   'h' },
-    { 0, 0, 0, 0},
+// clang-format off
+const option ArgumentParser::options[] = {
+    {"path",     required_argument, NULL, 'p'},
+    {"dev-path", required_argument, NULL, 'o'},
+    {"help",     no_argument,       NULL, 'h'},
+    {0, 0, 0, 0},
 };
+// clang-format on
 
 const char* ArgumentParser::optionstr = "o:p:?h";
 
diff --git a/argument.hpp b/argument.hpp
index ed2399a..e6acaf3 100644
--- a/argument.hpp
+++ b/argument.hpp
@@ -1,28 +1,29 @@
 #pragma once
 
 #include <getopt.h>
+
 #include <map>
 #include <string>
 
 class ArgumentParser
 {
-    public:
-        ArgumentParser(int argc, char** argv);
-        const std::string& operator[](const std::string& opt);
+  public:
+    ArgumentParser(int argc, char** argv);
+    const std::string& operator[](const std::string& opt);
 
-        static void usage(char** argv);
+    static void usage(char** argv);
 
-        static const std::string true_string;
-        static const std::string empty_string;
+    static const std::string true_string;
+    static const std::string empty_string;
 
-    private:
-        std::map<const std::string, std::string> arguments;
+  private:
+    std::map<const std::string, std::string> arguments;
 
-        static const option options[];
-        static const char* optionstr;
+    static const option options[];
+    static const char* optionstr;
 
-    private:
-        ArgumentParser() {};
+  private:
+    ArgumentParser(){};
 };
 
 // vim: tabstop=8 expandtab shiftwidth=4 softtabstop=4
diff --git a/env.cpp b/env.cpp
index 677f6fb..8dbb679 100644
--- a/env.cpp
+++ b/env.cpp
@@ -14,13 +14,15 @@
  * limitations under the License.
  */
 
+#include "env.hpp"
+
+#include "hwmon.hpp"
+
 #include <cstdlib>
 #include <fstream>
 
-#include "env.hpp"
-#include "hwmon.hpp"
-
-namespace env {
+namespace env
+{
 
 std::string getEnv(const char* key)
 {
@@ -28,8 +30,7 @@
     return (value) ? std::string(value) : std::string();
 }
 
-std::string getEnv(
-    const char* prefix, const SensorSet::key_type& sensor)
+std::string getEnv(const char* prefix, const SensorSet::key_type& sensor)
 {
     std::string key;
 
@@ -41,19 +42,15 @@
     return getEnv(key.c_str());
 }
 
-std::string getEnv(
-    const char* prefix,
-    const std::string& type,
-    const std::string& id)
+std::string getEnv(const char* prefix, const std::string& type,
+                   const std::string& id)
 {
     SensorSet::key_type sensor{type, id};
     return getEnv(prefix, sensor);
 }
 
-std::string getIndirectID(
-        std::string path,
-        const std::string& fileSuffix,
-        const SensorSet::key_type& sensor)
+std::string getIndirectID(std::string path, const std::string& fileSuffix,
+                          const SensorSet::key_type& sensor)
 {
     std::string content;
 
@@ -65,13 +62,12 @@
     std::ifstream handle(path.c_str());
     if (!handle.fail())
     {
-        content.assign(
-                (std::istreambuf_iterator<char>(handle)),
-                (std::istreambuf_iterator<char>()));
+        content.assign((std::istreambuf_iterator<char>(handle)),
+                       (std::istreambuf_iterator<char>()));
 
         if (!content.empty())
         {
-            //remove the newline
+            // remove the newline
             content.pop_back();
         }
     }
@@ -79,6 +75,6 @@
     return content;
 }
 
-}  // namespace env
+} // namespace env
 
 // vim: tabstop=8 expandtab shiftwidth=4 softtabstop=4
diff --git a/env.hpp b/env.hpp
index 56dd2aa..b3ddff5 100644
--- a/env.hpp
+++ b/env.hpp
@@ -1,10 +1,11 @@
 #pragma once
 
-#include <string>
-
 #include "sensorset.hpp"
 
-namespace env {
+#include <string>
+
+namespace env
+{
 
 /** @brief Reads an environment variable
  *
@@ -25,8 +26,7 @@
  *
  *  @return string - the env var value
  */
-std::string getEnv(
-    const char* prefix, const SensorSet::key_type& sensor);
+std::string getEnv(const char* prefix, const SensorSet::key_type& sensor);
 
 /** @brief Reads an environment variable, and takes type and id separately
  *
@@ -36,10 +36,8 @@
  *
  *  @return string - the env var value
  */
-std::string getEnv(
-    const char* prefix,
-    const std::string& type,
-    const std::string& id);
+std::string getEnv(const char* prefix, const std::string& type,
+                   const std::string& id);
 
 /** @brief Gets the ID for the sensor with a level of indirection
  *
@@ -50,9 +48,7 @@
  *  @param[in] fileSuffix - The file suffix
  *  @param[in] sensor - Sensor details
  */
-std::string getIndirectID(
-    std::string path,
-    const std::string& fileSuffix,
-    const SensorSet::key_type& sensor);
+std::string getIndirectID(std::string path, const std::string& fileSuffix,
+                          const SensorSet::key_type& sensor);
 
-}  // namespace env
+} // namespace env
diff --git a/fan_pwm.cpp b/fan_pwm.cpp
index 1808f5d..f814c0a 100644
--- a/fan_pwm.cpp
+++ b/fan_pwm.cpp
@@ -1,15 +1,15 @@
-#include "env.hpp"
 #include "fan_pwm.hpp"
+
+#include "env.hpp"
 #include "hwmon.hpp"
 #include "hwmonio.hpp"
 #include "sensorset.hpp"
 #include "sysfs.hpp"
 
-#include <phosphor-logging/elog-errors.hpp>
-#include <xyz/openbmc_project/Control/Device/error.hpp>
-
 #include <experimental/filesystem>
+#include <phosphor-logging/elog-errors.hpp>
 #include <string>
+#include <xyz/openbmc_project/Control/Device/error.hpp>
 
 using namespace phosphor::logging;
 
@@ -21,32 +21,22 @@
     using namespace std::literals;
 
     std::string empty;
-    //Write target out to sysfs
+    // Write target out to sysfs
     try
     {
-        ioAccess->write(
-            value,
-            type,
-            id,
-            empty,
-            hwmonio::retries,
-            hwmonio::delay);
+        ioAccess->write(value, type, id, empty, hwmonio::retries,
+                        hwmonio::delay);
     }
     catch (const std::system_error& e)
     {
-        using namespace sdbusplus::xyz::openbmc_project::Control::
-            Device::Error;
+        using namespace sdbusplus::xyz::openbmc_project::Control::Device::Error;
         report<WriteFailure>(
-            xyz::openbmc_project::Control::Device::
-            WriteFailure::CALLOUT_ERRNO(e.code().value()),
-            xyz::openbmc_project::Control::Device::
-            WriteFailure::CALLOUT_DEVICE_PATH(devPath.c_str()));
+            xyz::openbmc_project::Control::Device::WriteFailure::CALLOUT_ERRNO(
+                e.code().value()),
+            xyz::openbmc_project::Control::Device::WriteFailure::
+                CALLOUT_DEVICE_PATH(devPath.c_str()));
 
-        auto file = sysfs::make_sysfs_path(
-                        ioAccess->path(),
-                        type,
-                        id,
-                        empty);
+        auto file = sysfs::make_sysfs_path(ioAccess->path(), type, id, empty);
 
         log<level::INFO>("Logging failing sysfs file",
                          phosphor::logging::entry("FILE=%s", file.c_str()));
@@ -58,4 +48,3 @@
 }
 
 } // namespace hwmon
-
diff --git a/fan_pwm.hpp b/fan_pwm.hpp
index 61c0bf6..e80dde0 100644
--- a/fan_pwm.hpp
+++ b/fan_pwm.hpp
@@ -1,11 +1,11 @@
 #pragma once
 
-#include <memory>
-
 #include "hwmonio.hpp"
 #include "interface.hpp"
 #include "sysfs.hpp"
 
+#include <memory>
+
 namespace hwmon
 {
 
@@ -17,49 +17,43 @@
  */
 class FanPwm : public FanPwmObject
 {
-    public:
-
-        /**
-         * @brief Constructs FanPwm Object
-         *
-         * @param[in] io - HwmonIO
-         * @param[in] devPath - The /sys/devices sysfs path
-         * @param[in] id - The hwmon id
-         * @param[in] bus - Dbus bus object
-         * @param[in] objPath - Dbus object path
-         * @param[in] defer - Dbus object registration defer
-         */
+  public:
+    /**
+     * @brief Constructs FanPwm Object
+     *
+     * @param[in] io - HwmonIO
+     * @param[in] devPath - The /sys/devices sysfs path
+     * @param[in] id - The hwmon id
+     * @param[in] bus - Dbus bus object
+     * @param[in] objPath - Dbus object path
+     * @param[in] defer - Dbus object registration defer
+     */
     FanPwm(std::unique_ptr<hwmonio::HwmonIOInterface> io,
-           const std::string& devPath,
-           const std::string& id,
-           sdbusplus::bus::bus& bus,
-           const char* objPath,
-           bool defer,
-           uint64_t target) : FanPwmObject(bus, objPath, defer),
-                id(id),
-                ioAccess(std::move(io)),
-                devPath(devPath)
-        {
-            FanPwmObject::target(target);
-        }
+           const std::string& devPath, const std::string& id,
+           sdbusplus::bus::bus& bus, const char* objPath, bool defer,
+           uint64_t target) :
+        FanPwmObject(bus, objPath, defer),
+        id(id), ioAccess(std::move(io)), devPath(devPath)
+    {
+        FanPwmObject::target(target);
+    }
 
-        /**
-         * @brief Set the value of target
-         *
-         * @return Value of target
-         */
-        uint64_t target(uint64_t value) override;
+    /**
+     * @brief Set the value of target
+     *
+     * @return Value of target
+     */
+    uint64_t target(uint64_t value) override;
 
-    private:
-        /** @brief hwmon type */
-        static constexpr auto type = "pwm";
-        /** @brief hwmon id */
-        std::string id;
-        /** @brief Hwmon sysfs access. */
-        std::unique_ptr<hwmonio::HwmonIOInterface> ioAccess;
-        /** @brief Physical device path. */
-        std::string devPath;
+  private:
+    /** @brief hwmon type */
+    static constexpr auto type = "pwm";
+    /** @brief hwmon id */
+    std::string id;
+    /** @brief Hwmon sysfs access. */
+    std::unique_ptr<hwmonio::HwmonIOInterface> ioAccess;
+    /** @brief Physical device path. */
+    std::string devPath;
 };
 
 } // namespace hwmon
-
diff --git a/fan_speed.cpp b/fan_speed.cpp
index 9e297bc..db683a2 100644
--- a/fan_speed.cpp
+++ b/fan_speed.cpp
@@ -1,12 +1,14 @@
-#include <phosphor-logging/elog-errors.hpp>
-#include <xyz/openbmc_project/Control/Device/error.hpp>
-#include "sensorset.hpp"
-#include "env.hpp"
 #include "fan_speed.hpp"
+
+#include "env.hpp"
 #include "hwmon.hpp"
 #include "hwmonio.hpp"
+#include "sensorset.hpp"
 #include "sysfs.hpp"
 
+#include <phosphor-logging/elog-errors.hpp>
+#include <xyz/openbmc_project/Control/Device/error.hpp>
+
 using namespace phosphor::logging;
 
 namespace hwmon
@@ -18,36 +20,27 @@
 
     if (curValue != value)
     {
-        //Write target out to sysfs
+        // Write target out to sysfs
         try
         {
-            ioAccess->write(
-                    value,
-                    type,
-                    id,
-                    entry::target,
-                    hwmonio::retries,
-                    hwmonio::delay);
-
+            ioAccess->write(value, type, id, entry::target, hwmonio::retries,
+                            hwmonio::delay);
         }
         catch (const std::system_error& e)
         {
-            using namespace sdbusplus::xyz::openbmc_project::Control::
-                Device::Error;
+            using namespace sdbusplus::xyz::openbmc_project::Control::Device::
+                Error;
             report<WriteFailure>(
-                    xyz::openbmc_project::Control::Device::
-                        WriteFailure::CALLOUT_ERRNO(e.code().value()),
-                    xyz::openbmc_project::Control::Device::
-                        WriteFailure::CALLOUT_DEVICE_PATH(devPath.c_str()));
+                xyz::openbmc_project::Control::Device::WriteFailure::
+                    CALLOUT_ERRNO(e.code().value()),
+                xyz::openbmc_project::Control::Device::WriteFailure::
+                    CALLOUT_DEVICE_PATH(devPath.c_str()));
 
-            auto file = sysfs::make_sysfs_path(
-                    ioAccess->path(),
-                    type,
-                    id,
-                    entry::target);
+            auto file = sysfs::make_sysfs_path(ioAccess->path(), type, id,
+                                               entry::target);
 
             log<level::INFO>("Logging failing sysfs file",
-                    phosphor::logging::entry("FILE=%s", file.c_str()));
+                             phosphor::logging::entry("FILE=%s", file.c_str()));
 
             exit(EXIT_FAILURE);
         }
@@ -56,7 +49,6 @@
     return FanSpeedObject::target(value);
 }
 
-
 void FanSpeed::enable()
 {
     auto enable = env::getEnv("ENABLE", type, id);
@@ -66,37 +58,29 @@
 
         try
         {
-            ioAccess->write(
-                    val,
-                    type::pwm,
-                    id,
-                    entry::enable,
-                    hwmonio::retries,
-                    hwmonio::delay);
+            ioAccess->write(val, type::pwm, id, entry::enable, hwmonio::retries,
+                            hwmonio::delay);
         }
         catch (const std::system_error& e)
         {
-            using namespace sdbusplus::xyz::openbmc_project::Control::
-                Device::Error;
+            using namespace sdbusplus::xyz::openbmc_project::Control::Device::
+                Error;
             phosphor::logging::report<WriteFailure>(
-                    xyz::openbmc_project::Control::Device::
-                        WriteFailure::CALLOUT_ERRNO(e.code().value()),
-                    xyz::openbmc_project::Control::Device::
-                        WriteFailure::CALLOUT_DEVICE_PATH(devPath.c_str()));
+                xyz::openbmc_project::Control::Device::WriteFailure::
+                    CALLOUT_ERRNO(e.code().value()),
+                xyz::openbmc_project::Control::Device::WriteFailure::
+                    CALLOUT_DEVICE_PATH(devPath.c_str()));
 
-            auto fullPath = sysfs::make_sysfs_path(
-                    ioAccess->path(),
-                    type::pwm,
-                    id,
-                    entry::enable);
+            auto fullPath = sysfs::make_sysfs_path(ioAccess->path(), type::pwm,
+                                                   id, entry::enable);
 
-            log<level::INFO>("Logging failing sysfs file",
-                    phosphor::logging::entry("FILE=%s", fullPath.c_str()));
+            log<level::INFO>(
+                "Logging failing sysfs file",
+                phosphor::logging::entry("FILE=%s", fullPath.c_str()));
 
             exit(EXIT_FAILURE);
         }
     }
 }
 
-
 } // namespace hwmon
diff --git a/fan_speed.hpp b/fan_speed.hpp
index 9b4ad63..96d408e 100644
--- a/fan_speed.hpp
+++ b/fan_speed.hpp
@@ -1,11 +1,11 @@
 #pragma once
 
-#include <memory>
-
 #include "hwmonio.hpp"
 #include "interface.hpp"
 #include "sysfs.hpp"
 
+#include <memory>
+
 namespace hwmon
 {
 
@@ -17,56 +17,50 @@
  */
 class FanSpeed : public FanSpeedObject
 {
-    public:
+  public:
+    /**
+     * @brief Constructs FanSpeed Object
+     *
+     * @param[in] io -  HwmonIO(instance path) (ex /sys/class/hwmon/hwmon1)
+     * @param[in] devPath - The /sys/devices sysfs path
+     * @param[in] id - The hwmon id
+     * @param[in] bus - Dbus bus object
+     * @param[in] objPath - Dbus object path
+     * @param[in] defer - Dbus object registration defer
+     * @param[in] target - initial target speed value
+     */
+    FanSpeed(std::unique_ptr<hwmonio::HwmonIOInterface> io,
+             const std::string& devPath, const std::string& id,
+             sdbusplus::bus::bus& bus, const char* objPath, bool defer,
+             uint64_t target) :
+        FanSpeedObject(bus, objPath, defer),
+        id(id), ioAccess(std::move(io)), devPath(devPath)
+    {
+        FanSpeedObject::target(target);
+    }
 
-        /**
-         * @brief Constructs FanSpeed Object
-         *
-         * @param[in] io -  HwmonIO(instance path) (ex /sys/class/hwmon/hwmon1)
-         * @param[in] devPath - The /sys/devices sysfs path
-         * @param[in] id - The hwmon id
-         * @param[in] bus - Dbus bus object
-         * @param[in] objPath - Dbus object path
-         * @param[in] defer - Dbus object registration defer
-         * @param[in] target - initial target speed value
-         */
-        FanSpeed(std::unique_ptr<hwmonio::HwmonIOInterface> io,
-                 const std::string& devPath,
-                 const std::string& id,
-                 sdbusplus::bus::bus& bus,
-                 const char* objPath,
-                 bool defer,
-                 uint64_t target) : FanSpeedObject(bus, objPath, defer),
-                    id(id),
-                    ioAccess(std::move(io)),
-                    devPath(devPath)
-        {
-            FanSpeedObject::target(target);
-        }
+    /**
+     * @brief Set the value of target
+     *
+     * @return Value of target
+     */
+    uint64_t target(uint64_t value) override;
 
-        /**
-         * @brief Set the value of target
-         *
-         * @return Value of target
-         */
-        uint64_t target(uint64_t value) override;
+    /**
+     * @brief Writes the pwm_enable sysfs entry if the
+     *        env var with the value to write is present
+     */
+    void enable();
 
-        /**
-         * @brief Writes the pwm_enable sysfs entry if the
-         *        env var with the value to write is present
-         */
-        void enable();
-
-    private:
-        /** @brief hwmon type */
-        static constexpr auto type = "fan";
-        /** @brief hwmon id */
-        std::string id;
-        /** @brief Hwmon sysfs access. */
-        std::unique_ptr<hwmonio::HwmonIOInterface> ioAccess;
-        /** @brief Physical device path. */
-        std::string devPath;
-
+  private:
+    /** @brief hwmon type */
+    static constexpr auto type = "fan";
+    /** @brief hwmon id */
+    std::string id;
+    /** @brief Hwmon sysfs access. */
+    std::unique_ptr<hwmonio::HwmonIOInterface> ioAccess;
+    /** @brief Physical device path. */
+    std::string devPath;
 };
 
 } // namespace hwmon
diff --git a/hwmon.cpp b/hwmon.cpp
index 4eb47ae..adde6e4 100644
--- a/hwmon.cpp
+++ b/hwmon.cpp
@@ -1,17 +1,14 @@
 #include "hwmon.hpp"
 
-namespace hwmon {
+namespace hwmon
+{
 
 bool getAttributes(const std::string& type, Attributes& attributes)
 {
     // *INDENT-OFF*
-    auto a = std::find_if(
-                typeAttrMap.begin(),
-                typeAttrMap.end(),
-                [&](const auto & e)
-                {
-                   return type == getHwmonType(e);
-                });
+    auto a =
+        std::find_if(typeAttrMap.begin(), typeAttrMap.end(),
+                     [&](const auto& e) { return type == getHwmonType(e); });
     // *INDENT-ON*
 
     if (a == typeAttrMap.end())
@@ -23,4 +20,4 @@
     return true;
 }
 
-}  //  namespace hwmon
+} //  namespace hwmon
diff --git a/hwmon.hpp b/hwmon.hpp
index 5a7a90f..4f4545c 100644
--- a/hwmon.hpp
+++ b/hwmon.hpp
@@ -1,10 +1,10 @@
 #pragma once
 
+#include "interface.hpp"
+
 #include <string>
 #include <tuple>
 
-#include "interface.hpp"
-
 namespace hwmon
 {
 namespace entry
@@ -20,7 +20,7 @@
 static const std::string target = ctarget;
 static const std::string enable = cenable;
 static const std::string fault = cfault;
-}
+} // namespace entry
 
 namespace type
 {
@@ -32,7 +32,6 @@
 static constexpr auto cpower = "power";
 static constexpr auto cpwm = "pwm";
 
-
 static const std::string fan = cfan;
 static const std::string temp = ctemp;
 static const std::string volt = cvolt;
@@ -40,44 +39,25 @@
 static const std::string energy = cenergy;
 static const std::string power = cpower;
 static const std::string pwm = cpwm;
-}
+} // namespace type
 
-static constexpr auto typeAttrMap =
-{
+static constexpr auto typeAttrMap = {
     // 1 - hwmon class
     // 2 - unit
     // 3 - sysfs scaling factor
     // 4 - namespace
-    std::make_tuple(
-        hwmon::type::ctemp,
-        ValueInterface::Unit::DegreesC,
-        -3,
-        "temperature"),
-    std::make_tuple(
-        hwmon::type::cfan,
-        ValueInterface::Unit::RPMS,
-        0,
-        "fan_tach"),
-    std::make_tuple(
-        hwmon::type::cvolt,
-        ValueInterface::Unit::Volts,
-        -3,
-        "voltage"),
-    std::make_tuple(
-        hwmon::type::ccurr,
-        ValueInterface::Unit::Amperes,
-        -3,
-        "current"),
-    std::make_tuple(
-        hwmon::type::cenergy,
-        ValueInterface::Unit::Joules,
-        -6,
-        "energy"),
-    std::make_tuple(
-        hwmon::type::cpower,
-        ValueInterface::Unit::Watts,
-        -6,
-        "power"),
+    std::make_tuple(hwmon::type::ctemp, ValueInterface::Unit::DegreesC, -3,
+                    "temperature"),
+    std::make_tuple(hwmon::type::cfan, ValueInterface::Unit::RPMS, 0,
+                    "fan_tach"),
+    std::make_tuple(hwmon::type::cvolt, ValueInterface::Unit::Volts, -3,
+                    "voltage"),
+    std::make_tuple(hwmon::type::ccurr, ValueInterface::Unit::Amperes, -3,
+                    "current"),
+    std::make_tuple(hwmon::type::cenergy, ValueInterface::Unit::Joules, -6,
+                    "energy"),
+    std::make_tuple(hwmon::type::cpower, ValueInterface::Unit::Watts, -6,
+                    "power"),
 };
 
 inline auto getHwmonType(decltype(typeAttrMap)::const_reference attrs)
@@ -101,8 +81,8 @@
 }
 
 using AttributeIterator = decltype(*typeAttrMap.begin());
-using Attributes
-    = std::remove_cv<std::remove_reference<AttributeIterator>::type>::type;
+using Attributes =
+    std::remove_cv<std::remove_reference<AttributeIterator>::type>::type;
 
 /** @brief Get Attribute tuple for the type
  *
@@ -113,6 +93,6 @@
  */
 bool getAttributes(const std::string& type, Attributes& attributes);
 
-}  //  namespace hwmon
+} //  namespace hwmon
 
 // vim: tabstop=8 expandtab shiftwidth=4 softtabstop=4
diff --git a/hwmonio.cpp b/hwmonio.cpp
index 97990ce..6c461b3 100644
--- a/hwmonio.cpp
+++ b/hwmonio.cpp
@@ -11,16 +11,19 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include "config.h"
+
+#include "hwmonio.hpp"
+
+#include "sysfs.hpp"
+
 #include <algorithm>
 #include <exception>
 #include <fstream>
 #include <thread>
 
-#include "config.h"
-#include "hwmonio.hpp"
-#include "sysfs.hpp"
-
-namespace hwmonio {
+namespace hwmonio
+{
 
 static constexpr auto retryableErrors = {
     /*
@@ -72,22 +75,16 @@
 {
 }
 
-int64_t HwmonIO::read(
-        const std::string& type,
-        const std::string& id,
-        const std::string& sensor,
-        size_t retries,
-        std::chrono::milliseconds delay) const
+int64_t HwmonIO::read(const std::string& type, const std::string& id,
+                      const std::string& sensor, size_t retries,
+                      std::chrono::milliseconds delay) const
 {
     int64_t val;
     std::ifstream ifs;
-    auto fullPath = sysfs::make_sysfs_path(
-            p, type, id, sensor);
+    auto fullPath = sysfs::make_sysfs_path(p, type, id, sensor);
 
-    ifs.exceptions(
-            std::ifstream::failbit |
-                std::ifstream::badbit |
-                std::ifstream::eofbit);
+    ifs.exceptions(std::ifstream::failbit | std::ifstream::badbit |
+                   std::ifstream::eofbit);
 
     while (true)
     {
@@ -112,21 +109,19 @@
             if (rc == ENOENT || rc == ENODEV)
             {
                 // If the directory or device disappeared then this application
-                // should gracefully exit.  There are race conditions between the
-                // unloading of a hwmon driver and the stopping of this service
-                // by systemd.  To prevent this application from falsely failing
-                // in these scenarios, it will simply exit if the directory or
-                // file can not be found.  It is up to the user(s) of this
-                // provided hwmon object to log the appropriate errors if the
-                // object disappears when it should not.
+                // should gracefully exit.  There are race conditions between
+                // the unloading of a hwmon driver and the stopping of this
+                // service by systemd.  To prevent this application from falsely
+                // failing in these scenarios, it will simply exit if the
+                // directory or file can not be found.  It is up to the user(s)
+                // of this provided hwmon object to log the appropriate errors
+                // if the object disappears when it should not.
                 exit(0);
             }
 
-            if (0 == std::count(
-                        retryableErrors.begin(),
-                        retryableErrors.end(),
-                        rc) ||
-                    !retries)
+            if (0 == std::count(retryableErrors.begin(), retryableErrors.end(),
+                                rc) ||
+                !retries)
             {
                 // Not a retryable error or out of retries.
 #ifdef NEGATIVE_ERRNO_ON_FAIL
@@ -148,23 +143,16 @@
     return val;
 }
 
-void HwmonIO::write(
-        uint32_t val,
-        const std::string& type,
-        const std::string& id,
-        const std::string& sensor,
-        size_t retries,
-        std::chrono::milliseconds delay) const
+void HwmonIO::write(uint32_t val, const std::string& type,
+                    const std::string& id, const std::string& sensor,
+                    size_t retries, std::chrono::milliseconds delay) const
 
 {
     std::ofstream ofs;
-    auto fullPath = sysfs::make_sysfs_path(
-            p, type, id, sensor);
+    auto fullPath = sysfs::make_sysfs_path(p, type, id, sensor);
 
-    ofs.exceptions(
-            std::ofstream::failbit |
-                std::ofstream::badbit |
-                std::ofstream::eofbit);
+    ofs.exceptions(std::ofstream::failbit | std::ofstream::badbit |
+                   std::ofstream::eofbit);
 
     // See comments in the read method for an explanation of the odd exception
     // handling behavior here.
@@ -195,11 +183,9 @@
                 exit(0);
             }
 
-            if (0 == std::count(
-                        retryableErrors.begin(),
-                        retryableErrors.end(),
-                        rc) ||
-                    !retries)
+            if (0 == std::count(retryableErrors.begin(), retryableErrors.end(),
+                                rc) ||
+                !retries)
             {
                 // Not a retryable error or out of retries.
 
@@ -221,4 +207,4 @@
     return p;
 }
 
-} // hwmonio
+} // namespace hwmonio
diff --git a/hwmonio.hpp b/hwmonio.hpp
index d49f4db..902888f 100644
--- a/hwmonio.hpp
+++ b/hwmonio.hpp
@@ -3,7 +3,8 @@
 #include <chrono>
 #include <string>
 
-namespace hwmonio {
+namespace hwmonio
+{
 
 static constexpr auto retries = 10;
 static constexpr auto delay = std::chrono::milliseconds{100};
@@ -16,25 +17,19 @@
  */
 class HwmonIOInterface
 {
-    public:
-        virtual ~HwmonIOInterface() = default;
+  public:
+    virtual ~HwmonIOInterface() = default;
 
-        virtual int64_t read(
-                const std::string& type,
-                const std::string& id,
-                const std::string& sensor,
-                size_t retries,
-                std::chrono::milliseconds delay) const = 0;
+    virtual int64_t read(const std::string& type, const std::string& id,
+                         const std::string& sensor, size_t retries,
+                         std::chrono::milliseconds delay) const = 0;
 
-        virtual void write(
-                uint32_t val,
-                const std::string& type,
-                const std::string& id,
-                const std::string& sensor,
-                size_t retries,
-                std::chrono::milliseconds delay) const = 0;
+    virtual void write(uint32_t val, const std::string& type,
+                       const std::string& id, const std::string& sensor,
+                       size_t retries,
+                       std::chrono::milliseconds delay) const = 0;
 
-        virtual std::string path() const = 0;
+    virtual std::string path() const = 0;
 };
 
 /** @class HwmonIO
@@ -48,79 +43,71 @@
  */
 class HwmonIO : public HwmonIOInterface
 {
-    public:
-        HwmonIO() = delete;
-        HwmonIO(const HwmonIO&) = default;
-        HwmonIO(HwmonIO&&) = default;
-        HwmonIO& operator=(const HwmonIO&) = default;
-        HwmonIO& operator=(HwmonIO&&) = default;
-        ~HwmonIO() = default;
+  public:
+    HwmonIO() = delete;
+    HwmonIO(const HwmonIO&) = default;
+    HwmonIO(HwmonIO&&) = default;
+    HwmonIO& operator=(const HwmonIO&) = default;
+    HwmonIO& operator=(HwmonIO&&) = default;
+    ~HwmonIO() = default;
 
-        /** @brief Constructor
-         *
-         *  @param[in] path - hwmon instance root - eg:
-         *      /sys/class/hwmon/hwmon<N>
-         */
-        explicit HwmonIO(const std::string& path);
+    /** @brief Constructor
+     *
+     *  @param[in] path - hwmon instance root - eg:
+     *      /sys/class/hwmon/hwmon<N>
+     */
+    explicit HwmonIO(const std::string& path);
 
-        /** @brief Perform formatted hwmon sysfs read.
-         *
-         *  Propagates any exceptions other than ENOENT.
-         *  ENOENT will result in a call to exit(0) in case
-         *  the underlying hwmon driver is unbound and
-         *  the program is inadvertently left running.
-         *
-         *  For possibly transient errors will retry up to
-         *  the specified number of times.
-         *
-         *  @param[in] type - The hwmon type (ex. temp).
-         *  @param[in] id - The hwmon id (ex. 1).
-         *  @param[in] sensor - The hwmon sensor (ex. input).
-         *  @param[in] retries - The number of times to retry.
-         *  @param[in] delay - The time to sleep between retry attempts.
-         *
-         *  @return val - The read value.
-         */
-        int64_t read(
-                const std::string& type,
-                const std::string& id,
-                const std::string& sensor,
-                size_t retries,
-                std::chrono::milliseconds delay) const override;
+    /** @brief Perform formatted hwmon sysfs read.
+     *
+     *  Propagates any exceptions other than ENOENT.
+     *  ENOENT will result in a call to exit(0) in case
+     *  the underlying hwmon driver is unbound and
+     *  the program is inadvertently left running.
+     *
+     *  For possibly transient errors will retry up to
+     *  the specified number of times.
+     *
+     *  @param[in] type - The hwmon type (ex. temp).
+     *  @param[in] id - The hwmon id (ex. 1).
+     *  @param[in] sensor - The hwmon sensor (ex. input).
+     *  @param[in] retries - The number of times to retry.
+     *  @param[in] delay - The time to sleep between retry attempts.
+     *
+     *  @return val - The read value.
+     */
+    int64_t read(const std::string& type, const std::string& id,
+                 const std::string& sensor, size_t retries,
+                 std::chrono::milliseconds delay) const override;
 
-        /** @brief Perform formatted hwmon sysfs write.
-         *
-         *  Propagates any exceptions other than ENOENT.
-         *  ENOENT will result in a call to exit(0) in case
-         *  the underlying hwmon driver is unbound and
-         *  the program is inadvertently left running.
-         *
-         *  For possibly transient errors will retry up to
-         *  the specified number of times.
-         *
-         *  @param[in] val - The value to be written.
-         *  @param[in] type - The hwmon type (ex. fan).
-         *  @param[in] id - The hwmon id (ex. 1).
-         *  @param[in] retries - The number of times to retry.
-         *  @param[in] delay - The time to sleep between retry attempts.
-         */
-        void write(
-                uint32_t val,
-                const std::string& type,
-                const std::string& id,
-                const std::string& sensor,
-                size_t retries,
-                std::chrono::milliseconds delay) const override;
+    /** @brief Perform formatted hwmon sysfs write.
+     *
+     *  Propagates any exceptions other than ENOENT.
+     *  ENOENT will result in a call to exit(0) in case
+     *  the underlying hwmon driver is unbound and
+     *  the program is inadvertently left running.
+     *
+     *  For possibly transient errors will retry up to
+     *  the specified number of times.
+     *
+     *  @param[in] val - The value to be written.
+     *  @param[in] type - The hwmon type (ex. fan).
+     *  @param[in] id - The hwmon id (ex. 1).
+     *  @param[in] retries - The number of times to retry.
+     *  @param[in] delay - The time to sleep between retry attempts.
+     */
+    void write(uint32_t val, const std::string& type, const std::string& id,
+               const std::string& sensor, size_t retries,
+               std::chrono::milliseconds delay) const override;
 
+    /** @brief Hwmon instance path access.
+     *
+     *  @return path - The hwmon instance path.
+     */
+    std::string path() const override;
 
-        /** @brief Hwmon instance path access.
-         *
-         *  @return path - The hwmon instance path.
-         */
-        std::string path() const override;
-
-    private:
-        std::string p;
+  private:
+    std::string p;
 };
 } // namespace hwmonio
 
diff --git a/interface.hpp b/interface.hpp
index a2fa21f..e8ec28e 100644
--- a/interface.hpp
+++ b/interface.hpp
@@ -1,12 +1,12 @@
 #pragma once
 
-#include "xyz/openbmc_project/Sensor/Value/server.hpp"
-#include "xyz/openbmc_project/Sensor/Threshold/Warning/server.hpp"
-#include "xyz/openbmc_project/Sensor/Threshold/Critical/server.hpp"
-#include "xyz/openbmc_project/Control/FanSpeed/server.hpp"
-#include "xyz/openbmc_project/Control/FanPwm/server.hpp"
-#include "xyz/openbmc_project/State/Decorator/OperationalStatus/server.hpp"
 #include <sdbusplus/server.hpp>
+#include <xyz/openbmc_project/Control/FanPwm/server.hpp>
+#include <xyz/openbmc_project/Control/FanSpeed/server.hpp>
+#include <xyz/openbmc_project/Sensor/Threshold/Critical/server.hpp>
+#include <xyz/openbmc_project/Sensor/Threshold/Warning/server.hpp>
+#include <xyz/openbmc_project/Sensor/Value/server.hpp>
+#include <xyz/openbmc_project/State/Decorator/OperationalStatus/server.hpp>
 
 template <typename... T>
 using ServerObject = typename sdbusplus::server::object::object<T...>;
@@ -25,8 +25,8 @@
 using FanPwmInterface =
     sdbusplus::xyz::openbmc_project::Control::server::FanPwm;
 using FanPwmObject = ServerObject<FanPwmInterface>;
-using StatusInterface =
-    sdbusplus::xyz::openbmc_project::State::Decorator::server::OperationalStatus;
+using StatusInterface = sdbusplus::xyz::openbmc_project::State::Decorator::
+    server::OperationalStatus;
 using StatusObject = ServerObject<StatusInterface>;
 
 enum class InterfaceType
diff --git a/mainloop.cpp b/mainloop.cpp
index 02c3ebb..cf5baaf 100644
--- a/mainloop.cpp
+++ b/mainloop.cpp
@@ -13,28 +13,29 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include <functional>
-#include <iostream>
-#include <memory>
-#include <cstdlib>
-#include <string>
-#include <unordered_set>
-#include <sstream>
-
-#include <phosphor-logging/elog-errors.hpp>
 #include "config.h"
+
+#include "mainloop.hpp"
+
 #include "env.hpp"
 #include "fan_pwm.hpp"
 #include "fan_speed.hpp"
 #include "hwmon.hpp"
 #include "hwmonio.hpp"
+#include "sensor.hpp"
 #include "sensorset.hpp"
 #include "sysfs.hpp"
-#include "mainloop.hpp"
 #include "targets.hpp"
 #include "thresholds.hpp"
-#include "sensor.hpp"
 
+#include <cstdlib>
+#include <functional>
+#include <iostream>
+#include <memory>
+#include <phosphor-logging/elog-errors.hpp>
+#include <sstream>
+#include <string>
+#include <unordered_set>
 #include <xyz/openbmc_project/Sensor/Device/error.hpp>
 
 using namespace phosphor::logging;
@@ -48,9 +49,11 @@
     &WarningObject::warningLow;
 decltype(Thresholds<WarningObject>::getHi) Thresholds<WarningObject>::getHi =
     &WarningObject::warningHigh;
-decltype(Thresholds<WarningObject>::alarmLo) Thresholds<WarningObject>::alarmLo =
+decltype(
+    Thresholds<WarningObject>::alarmLo) Thresholds<WarningObject>::alarmLo =
     &WarningObject::warningAlarmLow;
-decltype(Thresholds<WarningObject>::alarmHi) Thresholds<WarningObject>::alarmHi =
+decltype(
+    Thresholds<WarningObject>::alarmHi) Thresholds<WarningObject>::alarmHi =
     &WarningObject::warningAlarmHigh;
 
 // Initialization for Critical Objects
@@ -62,9 +65,11 @@
     &CriticalObject::criticalLow;
 decltype(Thresholds<CriticalObject>::getHi) Thresholds<CriticalObject>::getHi =
     &CriticalObject::criticalHigh;
-decltype(Thresholds<CriticalObject>::alarmLo) Thresholds<CriticalObject>::alarmLo =
+decltype(
+    Thresholds<CriticalObject>::alarmLo) Thresholds<CriticalObject>::alarmLo =
     &CriticalObject::criticalAlarmLow;
-decltype(Thresholds<CriticalObject>::alarmHi) Thresholds<CriticalObject>::alarmHi =
+decltype(
+    Thresholds<CriticalObject>::alarmHi) Thresholds<CriticalObject>::alarmHi =
     &CriticalObject::criticalAlarmHigh;
 
 std::string MainLoop::getID(SensorSet::container_t::const_reference sensor)
@@ -87,10 +92,8 @@
     auto mode = env::getEnv("MODE", sensor.first);
     if (!mode.empty())
     {
-        id = env::getIndirectID(
-                _hwmonRoot + '/' + _instance + '/',
-                mode,
-                sensor.first);
+        id = env::getIndirectID(_hwmonRoot + '/' + _instance + '/', mode,
+                                sensor.first);
 
         if (id.empty())
         {
@@ -105,8 +108,8 @@
     return id;
 }
 
-SensorIdentifiers MainLoop::getIdentifiers(
-        SensorSet::container_t::const_reference sensor)
+SensorIdentifiers
+    MainLoop::getIdentifiers(SensorSet::container_t::const_reference sensor)
 {
     std::string id = getID(sensor);
     std::string label;
@@ -117,8 +120,7 @@
         label = env::getEnv("LABEL", sensor.first.first, id);
     }
 
-    return std::make_tuple(std::move(id),
-                           std::move(label));
+    return std::make_tuple(std::move(id), std::move(label));
 }
 
 /**
@@ -129,8 +131,8 @@
  * are created and the InterfacesAdded signal is emitted. The object's state
  * data is then returned for sensor state monitoring within the main loop.
  */
-optional_ns::optional<ObjectStateData> MainLoop::getObject(
-        SensorSet::container_t::const_reference sensor)
+optional_ns::optional<ObjectStateData>
+    MainLoop::getObject(SensorSet::container_t::const_reference sensor)
 {
     auto properties = getIdentifiers(sensor);
     if (std::get<sensorID>(properties).empty() ||
@@ -145,9 +147,8 @@
         return {};
     }
 
-    auto sensorObj = std::make_unique<sensor::Sensor>(sensor.first,
-                                                      ioAccess,
-                                                      _devPath);
+    auto sensorObj =
+        std::make_unique<sensor::Sensor>(sensor.first, ioAccess, _devPath);
 
     // Get list of return codes for removing sensors on device
     auto devRmRCs = env::getEnv("REMOVERCS");
@@ -168,8 +169,7 @@
         // don't retry on errors when reading its value
         std::get<size_t>(retryIO) = 0;
     }
-    auto valueInterface = static_cast<
-            std::shared_ptr<ValueObject>>(nullptr);
+    auto valueInterface = static_cast<std::shared_ptr<ValueObject>>(nullptr);
     try
     {
         // Add status interface based on _fault file being present
@@ -178,11 +178,9 @@
     }
     catch (const std::system_error& e)
     {
-        auto file = sysfs::make_sysfs_path(
-                ioAccess.path(),
-                sensor.first.first,
-                sensor.first.second,
-                hwmon::entry::cinput);
+        auto file =
+            sysfs::make_sysfs_path(ioAccess.path(), sensor.first.first,
+                                   sensor.first.second, hwmon::entry::cinput);
 #ifndef REMOVE_ON_FAIL
         // Check sensorAdjusts for sensor removal RCs
         auto& sAdjusts = sensorObj->getAdjusts();
@@ -193,24 +191,22 @@
             {
                 // Trace for sensor not already removed from dbus
                 log<level::INFO>("Sensor not added to dbus for read fail",
-                        entry("FILE=%s", file.c_str()),
-                        entry("RC=%d", e.code().value()));
-                rmSensors[std::move(sensor.first)] =
-                        std::move(sensor.second);
+                                 entry("FILE=%s", file.c_str()),
+                                 entry("RC=%d", e.code().value()));
+                rmSensors[std::move(sensor.first)] = std::move(sensor.second);
             }
             return {};
         }
 #endif
-        using namespace sdbusplus::xyz::openbmc_project::
-                Sensor::Device::Error;
+        using namespace sdbusplus::xyz::openbmc_project::Sensor::Device::Error;
         report<ReadFailure>(
-            xyz::openbmc_project::Sensor::Device::
-                ReadFailure::CALLOUT_ERRNO(e.code().value()),
-            xyz::openbmc_project::Sensor::Device::
-                ReadFailure::CALLOUT_DEVICE_PATH(_devPath.c_str()));
+            xyz::openbmc_project::Sensor::Device::ReadFailure::CALLOUT_ERRNO(
+                e.code().value()),
+            xyz::openbmc_project::Sensor::Device::ReadFailure::
+                CALLOUT_DEVICE_PATH(_devPath.c_str()));
 
         log<level::INFO>("Logging failing sysfs file",
-                entry("FILE=%s", file.c_str()));
+                         entry("FILE=%s", file.c_str()));
 #ifdef REMOVE_ON_FAIL
         return {}; /* skip adding this sensor for now. */
 #else
@@ -218,17 +214,13 @@
 #endif
     }
     auto sensorValue = valueInterface->value();
-    addThreshold<WarningObject>(sensor.first.first,
-                                std::get<sensorID>(properties),
-                                sensorValue,
-                                info);
-    addThreshold<CriticalObject>(sensor.first.first,
-                                 std::get<sensorID>(properties),
-                                 sensorValue,
-                                 info);
+    addThreshold<WarningObject>(
+        sensor.first.first, std::get<sensorID>(properties), sensorValue, info);
+    addThreshold<CriticalObject>(
+        sensor.first.first, std::get<sensorID>(properties), sensorValue, info);
 
-    auto target = addTarget<hwmon::FanSpeed>(
-            sensor.first, ioAccess, _devPath, info);
+    auto target =
+        addTarget<hwmon::FanSpeed>(sensor.first, ioAccess, _devPath, info);
     if (target)
     {
         target->enable();
@@ -246,23 +238,12 @@
                           std::move(info));
 }
 
-MainLoop::MainLoop(
-    sdbusplus::bus::bus&& bus,
-    const std::string& param,
-    const std::string& path,
-    const std::string& devPath,
-    const char* prefix,
-    const char* root)
-    : _bus(std::move(bus)),
-      _manager(_bus, root),
-      _pathParam(param),
-      _hwmonRoot(),
-      _instance(),
-      _devPath(devPath),
-      _prefix(prefix),
-      _root(root),
-      state(),
-      ioAccess(path)
+MainLoop::MainLoop(sdbusplus::bus::bus&& bus, const std::string& param,
+                   const std::string& path, const std::string& devPath,
+                   const char* prefix, const char* root) :
+    _bus(std::move(bus)),
+    _manager(_bus, root), _pathParam(param), _hwmonRoot(), _instance(),
+    _devPath(devPath), _prefix(prefix), _root(root), state(), ioAccess(path)
 {
     // Strip off any trailing slashes.
     std::string p = path;
@@ -297,14 +278,12 @@
 
     sd_event_default(&loop);
 
-    std::function<void()> callback(std::bind(
-            &MainLoop::read, this));
+    std::function<void()> callback(std::bind(&MainLoop::read, this));
     try
     {
         timer = std::make_unique<phosphor::hwmon::Timer>(
-                                 loop, callback,
-                                 std::chrono::microseconds(_interval),
-                                 phosphor::hwmon::timer::ON);
+            loop, callback, std::chrono::microseconds(_interval),
+            phosphor::hwmon::timer::ON);
 
         // TODO: Issue#6 - Optionally look at polling interval sysfs entry.
 
@@ -336,9 +315,9 @@
             // std::tuple<SensorSet::mapped_type,
             //            std::string(Sensor Label),
             //            ObjectInfo>
-            auto value = std::make_tuple(std::move(i.second),
-                                         std::move((*object).first),
-                                         std::move((*object).second));
+            auto value =
+                std::make_tuple(std::move(i.second), std::move((*object).first),
+                                std::move((*object).second));
 
             state[std::move(i.first)] = std::move(value);
         }
@@ -352,8 +331,7 @@
 
     {
         std::stringstream ss;
-        ss << _prefix
-           << "-"
+        ss << _prefix << "-"
            << std::to_string(std::hash<std::string>{}(_devPath + _pathParam))
            << ".Hwmon1";
 
@@ -383,7 +361,8 @@
             // Read value from sensor.
             int64_t value;
             std::string input = hwmon::entry::cinput;
-            if (i.first.first == "pwm") {
+            if (i.first.first == "pwm")
+            {
                 input = "";
             }
 
@@ -396,13 +375,10 @@
                 if (it != obj.end())
                 {
                     auto fault = ioAccess.read(
-                            i.first.first,
-                            i.first.second,
-                            hwmon::entry::fault,
-                            hwmonio::retries,
-                            hwmonio::delay);
+                        i.first.first, i.first.second, hwmon::entry::fault,
+                        hwmonio::retries, hwmonio::delay);
                     auto statusIface = std::experimental::any_cast<
-                            std::shared_ptr<StatusObject>>(it->second);
+                        std::shared_ptr<StatusObject>>(it->second);
                     if (!statusIface->functional((fault == 0) ? true : false))
                     {
                         continue;
@@ -412,12 +388,8 @@
                 // Retry for up to a second if device is busy
                 // or has a transient error.
 
-                value = ioAccess.read(
-                        i.first.first,
-                        i.first.second,
-                        input,
-                        hwmonio::retries,
-                        hwmonio::delay);
+                value = ioAccess.read(i.first.first, i.first.second, input,
+                                      hwmonio::retries, hwmonio::delay);
 
                 value = sensorObjects[i.first]->adjustValue(value);
 
@@ -430,15 +402,16 @@
                     switch (iface.first)
                     {
                         case InterfaceType::VALUE:
-                            valueIface = std::experimental::any_cast<std::shared_ptr<ValueObject>>
-                                        (iface.second);
+                            valueIface = std::experimental::any_cast<
+                                std::shared_ptr<ValueObject>>(iface.second);
                             valueIface->value(value);
                             break;
                         case InterfaceType::WARN:
                             checkThresholds<WarningObject>(iface.second, value);
                             break;
                         case InterfaceType::CRIT:
-                            checkThresholds<CriticalObject>(iface.second, value);
+                            checkThresholds<CriticalObject>(iface.second,
+                                                            value);
                             break;
                         default:
                             break;
@@ -448,10 +421,8 @@
             catch (const std::system_error& e)
             {
                 auto file = sysfs::make_sysfs_path(
-                        ioAccess.path(),
-                        i.first.first,
-                        i.first.second,
-                        hwmon::entry::cinput);
+                    ioAccess.path(), i.first.first, i.first.second,
+                    hwmon::entry::cinput);
 #ifndef REMOVE_ON_FAIL
                 // Check sensorAdjusts for sensor removal RCs
                 auto& sAdjusts = sensorObjects[i.first]->getAdjusts();
@@ -462,26 +433,25 @@
                     {
                         // Trace for sensor not already removed from dbus
                         log<level::INFO>(
-                                "Remove sensor from dbus for read fail",
-                                entry("FILE=%s", file.c_str()),
-                                entry("RC=%d", e.code().value()));
+                            "Remove sensor from dbus for read fail",
+                            entry("FILE=%s", file.c_str()),
+                            entry("RC=%d", e.code().value()));
                         // Mark this sensor to be removed from dbus
                         rmSensors[i.first] = std::get<0>(i.second);
                     }
                     continue;
                 }
 #endif
-                using namespace sdbusplus::xyz::openbmc_project::
-                    Sensor::Device::Error;
+                using namespace sdbusplus::xyz::openbmc_project::Sensor::
+                    Device::Error;
                 report<ReadFailure>(
-                        xyz::openbmc_project::Sensor::Device::
-                            ReadFailure::CALLOUT_ERRNO(e.code().value()),
-                        xyz::openbmc_project::Sensor::Device::
-                            ReadFailure::CALLOUT_DEVICE_PATH(
-                                _devPath.c_str()));
+                    xyz::openbmc_project::Sensor::Device::ReadFailure::
+                        CALLOUT_ERRNO(e.code().value()),
+                    xyz::openbmc_project::Sensor::Device::ReadFailure::
+                        CALLOUT_DEVICE_PATH(_devPath.c_str()));
 
                 log<level::INFO>("Logging failing sysfs file",
-                        entry("FILE=%s", file.c_str()));
+                                 entry("FILE=%s", file.c_str()));
 
 #ifdef REMOVE_ON_FAIL
                 rmSensors[i.first] = std::get<0>(i.second);
@@ -506,7 +476,7 @@
         if (state.find(it->first) == state.end())
         {
             SensorSet::container_t::value_type ssValueType =
-                    std::make_pair(it->first, it->second);
+                std::make_pair(it->first, it->second);
             auto object = getObject(ssValueType);
             if (object)
             {
@@ -522,13 +492,10 @@
 
                 // Sensor object added, erase entry from removal list
                 auto file = sysfs::make_sysfs_path(
-                        ioAccess.path(),
-                        it->first.first,
-                        it->first.second,
-                        hwmon::entry::cinput);
-                log<level::INFO>(
-                        "Added sensor to dbus after successful read",
-                        entry("FILE=%s", file.c_str()));
+                    ioAccess.path(), it->first.first, it->first.second,
+                    hwmon::entry::cinput);
+                log<level::INFO>("Added sensor to dbus after successful read",
+                                 entry("FILE=%s", file.c_str()));
                 it = rmSensors.erase(it);
             }
             else
diff --git a/mainloop.hpp b/mainloop.hpp
index c3ed161..77419e5 100644
--- a/mainloop.hpp
+++ b/mainloop.hpp
@@ -1,18 +1,19 @@
 #pragma once
 
-#include <string>
-#include <vector>
+#include "hwmonio.hpp"
+#include "interface.hpp"
+#include "sensor.hpp"
+#include "sensorset.hpp"
+#include "sysfs.hpp"
+#include "timer.hpp"
+#include "types.hpp"
+
 #include <experimental/any>
 #include <experimental/optional>
 #include <memory>
 #include <sdbusplus/server.hpp>
-#include "types.hpp"
-#include "hwmonio.hpp"
-#include "sensorset.hpp"
-#include "sysfs.hpp"
-#include "interface.hpp"
-#include "timer.hpp"
-#include "sensor.hpp"
+#include <string>
+#include <vector>
 
 static constexpr auto default_interval = 1000000;
 
@@ -27,116 +28,113 @@
  */
 class MainLoop
 {
-    public:
-        MainLoop() = delete;
-        MainLoop(const MainLoop&) = delete;
-        MainLoop& operator=(const MainLoop&) = delete;
-        MainLoop(MainLoop&&) = default;
-        MainLoop& operator=(MainLoop&&) = default;
-        ~MainLoop() = default;
+  public:
+    MainLoop() = delete;
+    MainLoop(const MainLoop&) = delete;
+    MainLoop& operator=(const MainLoop&) = delete;
+    MainLoop(MainLoop&&) = default;
+    MainLoop& operator=(MainLoop&&) = default;
+    ~MainLoop() = default;
 
-        /** @brief Constructor
-         *
-         *  @param[in] bus - sdbusplus bus client connection.
-         *  @param[in] param - the path parameter provided
-         *  @param[in] path - hwmon sysfs instance to manage
-         *  @param[in] devPath - physical device sysfs path.
-         *  @param[in] prefix - DBus busname prefix.
-         *  @param[in] root - DBus sensors namespace root.
-         *
-         *  Any DBus objects are created relative to the DBus
-         *  sensors namespace root.
-         *
-         *  At startup, the application will own a busname with
-         *  the format <prefix>.hwmon<n>.
-         */
-        MainLoop(
-            sdbusplus::bus::bus&& bus,
-            const std::string& param,
-            const std::string& path,
-            const std::string& devPath,
-            const char* prefix,
-            const char* root);
+    /** @brief Constructor
+     *
+     *  @param[in] bus - sdbusplus bus client connection.
+     *  @param[in] param - the path parameter provided
+     *  @param[in] path - hwmon sysfs instance to manage
+     *  @param[in] devPath - physical device sysfs path.
+     *  @param[in] prefix - DBus busname prefix.
+     *  @param[in] root - DBus sensors namespace root.
+     *
+     *  Any DBus objects are created relative to the DBus
+     *  sensors namespace root.
+     *
+     *  At startup, the application will own a busname with
+     *  the format <prefix>.hwmon<n>.
+     */
+    MainLoop(sdbusplus::bus::bus&& bus, const std::string& param,
+             const std::string& path, const std::string& devPath,
+             const char* prefix, const char* root);
 
-        /** @brief Setup polling timer in a sd event loop and attach to D-Bus
-         *         event loop.
-         */
-        void run();
+    /** @brief Setup polling timer in a sd event loop and attach to D-Bus
+     *         event loop.
+     */
+    void run();
 
-        /** @brief Stop polling timer event loop from another thread.
-         *
-         *  Typically only used by testcases.
-         */
-        void shutdown() noexcept;
+    /** @brief Stop polling timer event loop from another thread.
+     *
+     *  Typically only used by testcases.
+     */
+    void shutdown() noexcept;
 
-    private:
-        using mapped_type = std::tuple<SensorSet::mapped_type, std::string, ObjectInfo>;
-        using SensorState = std::map<SensorSet::key_type, mapped_type>;
+  private:
+    using mapped_type =
+        std::tuple<SensorSet::mapped_type, std::string, ObjectInfo>;
+    using SensorState = std::map<SensorSet::key_type, mapped_type>;
 
-        /** @brief Read hwmon sysfs entries */
-        void read();
+    /** @brief Read hwmon sysfs entries */
+    void read();
 
-        /** @brief Set up D-Bus object state */
-        void init();
+    /** @brief Set up D-Bus object state */
+    void init();
 
-        /** @brief sdbusplus bus client connection. */
-        sdbusplus::bus::bus _bus;
-        /** @brief sdbusplus freedesktop.ObjectManager storage. */
-        sdbusplus::server::manager::manager _manager;
-        /** @brief the parameter path used. */
-        std::string _pathParam;
-        /** @brief hwmon sysfs class path. */
-        std::string _hwmonRoot;
-        /** @brief hwmon sysfs instance. */
-        std::string _instance;
-        /** @brief physical device sysfs path. */
-        std::string _devPath;
-        /** @brief DBus busname prefix. */
-        const char* _prefix;
-        /** @brief DBus sensors namespace root. */
-        const char* _root;
-        /** @brief DBus object state. */
-        SensorState state;
-        /** @brief Sleep interval in microseconds. */
-        uint64_t _interval = default_interval;
-        /** @brief Hwmon sysfs access. */
-        hwmonio::HwmonIO ioAccess;
-        /** @brief Timer */
-        std::unique_ptr<phosphor::hwmon::Timer> timer;
-        /** @brief the sd_event structure */
-        sd_event* loop = nullptr;
-        /** @brief Store the specifications of sensor objects */
-        std::map<SensorSet::key_type,
-                 std::unique_ptr<sensor::Sensor>> sensorObjects;
+    /** @brief sdbusplus bus client connection. */
+    sdbusplus::bus::bus _bus;
+    /** @brief sdbusplus freedesktop.ObjectManager storage. */
+    sdbusplus::server::manager::manager _manager;
+    /** @brief the parameter path used. */
+    std::string _pathParam;
+    /** @brief hwmon sysfs class path. */
+    std::string _hwmonRoot;
+    /** @brief hwmon sysfs instance. */
+    std::string _instance;
+    /** @brief physical device sysfs path. */
+    std::string _devPath;
+    /** @brief DBus busname prefix. */
+    const char* _prefix;
+    /** @brief DBus sensors namespace root. */
+    const char* _root;
+    /** @brief DBus object state. */
+    SensorState state;
+    /** @brief Sleep interval in microseconds. */
+    uint64_t _interval = default_interval;
+    /** @brief Hwmon sysfs access. */
+    hwmonio::HwmonIO ioAccess;
+    /** @brief Timer */
+    std::unique_ptr<phosphor::hwmon::Timer> timer;
+    /** @brief the sd_event structure */
+    sd_event* loop = nullptr;
+    /** @brief Store the specifications of sensor objects */
+    std::map<SensorSet::key_type, std::unique_ptr<sensor::Sensor>>
+        sensorObjects;
 
-        /**
-         * @brief Map of removed sensors
-         */
-        std::map<SensorSet::key_type, SensorSet::mapped_type> rmSensors;
+    /**
+     * @brief Map of removed sensors
+     */
+    std::map<SensorSet::key_type, SensorSet::mapped_type> rmSensors;
 
-        /**
-         * @brief Get the ID of the sensor
-         *
-         * @param[in] sensor - Sensor to get the ID of
-         */
-        std::string getID(SensorSet::container_t::const_reference sensor);
+    /**
+     * @brief Get the ID of the sensor
+     *
+     * @param[in] sensor - Sensor to get the ID of
+     */
+    std::string getID(SensorSet::container_t::const_reference sensor);
 
-        /**
-         * @brief Get the sensor identifiers
-         *
-         * @param[in] sensor - Sensor to get the identifiers of
-         */
-        SensorIdentifiers getIdentifiers(
-                SensorSet::container_t::const_reference sensor);
+    /**
+     * @brief Get the sensor identifiers
+     *
+     * @param[in] sensor - Sensor to get the identifiers of
+     */
+    SensorIdentifiers
+        getIdentifiers(SensorSet::container_t::const_reference sensor);
 
-        /**
-         * @brief Used to create and add sensor objects
-         *
-         * @param[in] sensor - Sensor to create/add object for
-         *
-         * @return - Optional
-         *     Object state data on success, nothing on failure
-         */
-        optional_ns::optional<ObjectStateData> getObject(
-                SensorSet::container_t::const_reference sensor);
+    /**
+     * @brief Used to create and add sensor objects
+     *
+     * @param[in] sensor - Sensor to create/add object for
+     *
+     * @return - Optional
+     *     Object state data on success, nothing on failure
+     */
+    optional_ns::optional<ObjectStateData>
+        getObject(SensorSet::container_t::const_reference sensor);
 };
diff --git a/readd.cpp b/readd.cpp
index 78edc77..be59962 100644
--- a/readd.cpp
+++ b/readd.cpp
@@ -13,13 +13,15 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include <iostream>
-#include <memory>
+#include "config.h"
+
 #include "argument.hpp"
 #include "mainloop.hpp"
-#include "config.h"
 #include "sysfs.hpp"
 
+#include <iostream>
+#include <memory>
+
 static void exit_with_error(const char* err, char** argv)
 {
     ArgumentParser::usage(argv);
@@ -71,13 +73,8 @@
         exit_with_error("Unable to determine callout path.", argv);
     }
 
-    MainLoop loop(
-        sdbusplus::bus::new_default(),
-        param,
-        path,
-        calloutPath,
-        BUSNAME_PREFIX,
-        SENSOR_ROOT);
+    MainLoop loop(sdbusplus::bus::new_default(), param, path, calloutPath,
+                  BUSNAME_PREFIX, SENSOR_ROOT);
     loop.run();
 
     return 0;
diff --git a/sensor.cpp b/sensor.cpp
index 6191688..bc5f34d 100644
--- a/sensor.cpp
+++ b/sensor.cpp
@@ -1,27 +1,26 @@
+#include "config.h"
+
+#include "sensor.hpp"
+
+#include "env.hpp"
+#include "hwmon.hpp"
+#include "sensorset.hpp"
+#include "sysfs.hpp"
+
 #include <cstring>
 #include <experimental/filesystem>
-
 #include <phosphor-logging/elog-errors.hpp>
 #include <xyz/openbmc_project/Sensor/Device/error.hpp>
 
-#include "config.h"
-#include "sensor.hpp"
-#include "sensorset.hpp"
-#include "hwmon.hpp"
-#include "env.hpp"
-#include "sysfs.hpp"
-
 namespace sensor
 {
 
 using namespace phosphor::logging;
 
 Sensor::Sensor(const SensorSet::key_type& sensor,
-               const hwmonio::HwmonIO& ioAccess,
-               const std::string& devPath) :
+               const hwmonio::HwmonIO& ioAccess, const std::string& devPath) :
     sensor(sensor),
-    ioAccess(ioAccess),
-    devPath(devPath)
+    ioAccess(ioAccess), devPath(devPath)
 {
     auto gain = env::getEnv("GAIN", sensor);
     if (!gain.empty())
@@ -47,8 +46,7 @@
     }
 
     // Convert to a char* for strtok
-    std::vector<char> rmRCs(rcList.c_str(),
-                            rcList.c_str() + rcList.size() + 1);
+    std::vector<char> rmRCs(rcList.c_str(), rcList.c_str() + rcList.size() + 1);
     auto rmRC = std::strtok(&rmRCs[0], ", ");
     while (rmRC != nullptr)
     {
@@ -83,15 +81,13 @@
 
     // Adjust based on gain and offset
     value = static_cast<decltype(value)>(
-                static_cast<double>(value) * sensorAdjusts.gain
-                    + sensorAdjusts.offset);
+        static_cast<double>(value) * sensorAdjusts.gain + sensorAdjusts.offset);
 
     return value;
 }
 
-std::shared_ptr<ValueObject> Sensor::addValue(
-        const RetryIO& retryIO,
-        ObjectInfo& info)
+std::shared_ptr<ValueObject> Sensor::addValue(const RetryIO& retryIO,
+                                              ObjectInfo& info)
 {
     static constexpr bool deferSignals = true;
 
@@ -105,8 +101,9 @@
     auto it = obj.find(InterfaceType::STATUS);
     if (it != obj.end())
     {
-        statusIface = std::experimental::any_cast<
-                std::shared_ptr<StatusObject>>(it->second);
+        statusIface =
+            std::experimental::any_cast<std::shared_ptr<StatusObject>>(
+                it->second);
     }
 
     // If there's no fault file or the sensor has a fault file and
@@ -115,16 +112,14 @@
     {
         // Retry for up to a second if device is busy
         // or has a transient error.
-        val = ioAccess.read(
-                sensor.first,
-                sensor.second,
-                hwmon::entry::cinput,
-                std::get<size_t>(retryIO),
-                std::get<std::chrono::milliseconds>(retryIO));
+        val = ioAccess.read(sensor.first, sensor.second, hwmon::entry::cinput,
+                            std::get<size_t>(retryIO),
+                            std::get<std::chrono::milliseconds>(retryIO));
         val = adjustValue(val);
     }
 
-    auto iface = std::make_shared<ValueObject>(bus, objPath.c_str(), deferSignals);
+    auto iface =
+        std::make_shared<ValueObject>(bus, objPath.c_str(), deferSignals);
     iface->value(val);
 
     hwmon::Attributes attrs;
@@ -135,12 +130,12 @@
     }
 
     auto maxValue = env::getEnv("MAXVALUE", sensor);
-    if(!maxValue.empty())
+    if (!maxValue.empty())
     {
         iface->maxValue(std::stoll(maxValue));
     }
     auto minValue = env::getEnv("MINVALUE", sensor);
-    if(!minValue.empty())
+    if (!minValue.empty())
     {
         iface->minValue(std::stoll(minValue));
     }
@@ -164,20 +159,15 @@
     std::string faultID = sensor.second;
     std::string entry = hwmon::entry::fault;
 
-    auto sysfsFullPath = sysfs::make_sysfs_path(ioAccess.path(),
-                                                faultName,
-                                                faultID,
-                                                entry);
+    auto sysfsFullPath =
+        sysfs::make_sysfs_path(ioAccess.path(), faultName, faultID, entry);
     if (fs::exists(sysfsFullPath))
     {
         bool functional = true;
         uint32_t fault = 0;
         try
         {
-            fault = ioAccess.read(faultName,
-                                  faultID,
-                                  entry,
-                                  hwmonio::retries,
+            fault = ioAccess.read(faultName, faultID, entry, hwmonio::retries,
                                   hwmonio::delay);
             if (fault != 0)
             {
@@ -186,24 +176,20 @@
         }
         catch (const std::system_error& e)
         {
-            using namespace sdbusplus::xyz::openbmc_project::
-                Sensor::Device::Error;
-            using metadata = xyz::openbmc_project::Sensor::
-                Device::ReadFailure;
+            using namespace sdbusplus::xyz::openbmc_project::Sensor::Device::
+                Error;
+            using metadata = xyz::openbmc_project::Sensor::Device::ReadFailure;
 
-            report<ReadFailure>(
-                    metadata::CALLOUT_ERRNO(e.code().value()),
-                    metadata::CALLOUT_DEVICE_PATH(devPath.c_str()));
+            report<ReadFailure>(metadata::CALLOUT_ERRNO(e.code().value()),
+                                metadata::CALLOUT_DEVICE_PATH(devPath.c_str()));
 
-            log<level::INFO>("Logging failing sysfs file",
-                    phosphor::logging::entry(
-                            "FILE=%s", sysfsFullPath.c_str()));
+            log<level::INFO>(
+                "Logging failing sysfs file",
+                phosphor::logging::entry("FILE=%s", sysfsFullPath.c_str()));
         }
 
-        iface = std::make_shared<StatusObject>(
-                bus,
-                objPath.c_str(),
-                deferSignals);
+        iface =
+            std::make_shared<StatusObject>(bus, objPath.c_str(), deferSignals);
         // Set functional property
         iface->functional(functional);
 
diff --git a/sensor.hpp b/sensor.hpp
index 9d48483..7005ea9 100644
--- a/sensor.hpp
+++ b/sensor.hpp
@@ -1,9 +1,10 @@
 #pragma once
 
-#include <unordered_set>
-#include "types.hpp"
-#include "sensorset.hpp"
 #include "hwmonio.hpp"
+#include "sensorset.hpp"
+#include "types.hpp"
+
+#include <unordered_set>
 
 namespace sensor
 {
@@ -23,97 +24,95 @@
  */
 class Sensor
 {
-    public:
-        Sensor() = delete;
-        Sensor(const Sensor&) = delete;
-        Sensor(Sensor&&) = default;
-        Sensor& operator=(const Sensor&) = delete;
-        Sensor& operator=(Sensor&&) = default;
-        ~Sensor() = default;
+  public:
+    Sensor() = delete;
+    Sensor(const Sensor&) = delete;
+    Sensor(Sensor&&) = default;
+    Sensor& operator=(const Sensor&) = delete;
+    Sensor& operator=(Sensor&&) = default;
+    ~Sensor() = default;
 
-        /**
-         * @brief Constructs Sensor object
-         *
-         * @param[in] sensor - A pair of sensor indentifiers
-         * @param[in] ioAccess - Hwmon sysfs access
-         * @param[in] devPath - Device sysfs path
-         */
-        explicit Sensor(const SensorSet::key_type& sensor,
-                        const hwmonio::HwmonIO& ioAccess,
-                        const std::string& devPath);
+    /**
+     * @brief Constructs Sensor object
+     *
+     * @param[in] sensor - A pair of sensor indentifiers
+     * @param[in] ioAccess - Hwmon sysfs access
+     * @param[in] devPath - Device sysfs path
+     */
+    explicit Sensor(const SensorSet::key_type& sensor,
+                    const hwmonio::HwmonIO& ioAccess,
+                    const std::string& devPath);
 
-        /**
-         * @brief Adds any sensor removal return codes for the sensor
-         * @details Add all return codes defined within a device's config file
-         * for the entire device or for the specific sensor.
-         *
-         * @param[in] rcList - List of return codes found for the sensor
-         */
-        void addRemoveRCs(const std::string& rcList);
+    /**
+     * @brief Adds any sensor removal return codes for the sensor
+     * @details Add all return codes defined within a device's config file
+     * for the entire device or for the specific sensor.
+     *
+     * @param[in] rcList - List of return codes found for the sensor
+     */
+    void addRemoveRCs(const std::string& rcList);
 
-        /**
-         * @brief Get the adjustments struct for the sensor
-         *
-         * @return - Sensor adjustment struct
-         */
-        inline const valueAdjust& getAdjusts()
-        {
-            return sensorAdjusts;
-        }
+    /**
+     * @brief Get the adjustments struct for the sensor
+     *
+     * @return - Sensor adjustment struct
+     */
+    inline const valueAdjust& getAdjusts()
+    {
+        return sensorAdjusts;
+    }
 
-        /**
-         * @brief Adjusts a sensor value
-         * @details Adjusts the value given by any gain and/or offset defined
-         * for this sensor object and returns that adjusted value.
-         *
-         * @param[in] value - Value to be adjusted
-         *
-         * @return - Adjusted sensor value
-         */
-        int64_t adjustValue(int64_t value);
+    /**
+     * @brief Adjusts a sensor value
+     * @details Adjusts the value given by any gain and/or offset defined
+     * for this sensor object and returns that adjusted value.
+     *
+     * @param[in] value - Value to be adjusted
+     *
+     * @return - Adjusted sensor value
+     */
+    int64_t adjustValue(int64_t value);
 
-        /**
-         * @brief Add value interface and value property for sensor
-         * @details When a sensor has an associated input file, the Sensor.Value
-         * interface is added along with setting the Value property to the
-         * corresponding value found in the input file.
-         *
-         * @param[in] retryIO - Hwmon sysfs file retry constraints
-         *                      (number of and delay between)
-         * @param[in] info - Sensor object information
-         *
-         * @return - Shared pointer to the value object
-         */
-        std::shared_ptr<ValueObject> addValue(
-                const RetryIO& retryIO,
-                ObjectInfo& info);
+    /**
+     * @brief Add value interface and value property for sensor
+     * @details When a sensor has an associated input file, the Sensor.Value
+     * interface is added along with setting the Value property to the
+     * corresponding value found in the input file.
+     *
+     * @param[in] retryIO - Hwmon sysfs file retry constraints
+     *                      (number of and delay between)
+     * @param[in] info - Sensor object information
+     *
+     * @return - Shared pointer to the value object
+     */
+    std::shared_ptr<ValueObject> addValue(const RetryIO& retryIO,
+                                          ObjectInfo& info);
 
-        /**
-         * @brief Add status interface and functional property for sensor
-         * @details When a sensor has an associated fault file, the
-         * OperationalStatus interface is added along with setting the
-         * Functional property to the corresponding value found in the
-         * fault file.
-         *
-         * @param[in] info - Sensor object information
-         *
-         * @return - Shared pointer to the status object
-         */
-        std::shared_ptr<StatusObject> addStatus(
-                ObjectInfo& info);
+    /**
+     * @brief Add status interface and functional property for sensor
+     * @details When a sensor has an associated fault file, the
+     * OperationalStatus interface is added along with setting the
+     * Functional property to the corresponding value found in the
+     * fault file.
+     *
+     * @param[in] info - Sensor object information
+     *
+     * @return - Shared pointer to the status object
+     */
+    std::shared_ptr<StatusObject> addStatus(ObjectInfo& info);
 
-    private:
-        /** @brief Sensor object's identifiers */
-        SensorSet::key_type sensor;
+  private:
+    /** @brief Sensor object's identifiers */
+    SensorSet::key_type sensor;
 
-        /** @brief Hwmon sysfs access. */
-        const hwmonio::HwmonIO& ioAccess;
+    /** @brief Hwmon sysfs access. */
+    const hwmonio::HwmonIO& ioAccess;
 
-        /** @brief Physical device sysfs path. */
-        const std::string& devPath;
+    /** @brief Physical device sysfs path. */
+    const std::string& devPath;
 
-        /** @brief Structure for storing sensor adjustments */
-        valueAdjust sensorAdjusts;
+    /** @brief Structure for storing sensor adjustments */
+    valueAdjust sensorAdjusts;
 };
 
 } // namespace sensor
diff --git a/sensorset.cpp b/sensorset.cpp
index 2952775..268ef3d 100644
--- a/sensorset.cpp
+++ b/sensorset.cpp
@@ -13,17 +13,18 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include <experimental/filesystem>
-#include <regex>
-#include <iostream>
 #include "sensorset.hpp"
+
 #include "hwmon.hpp"
 
+#include <experimental/filesystem>
+#include <iostream>
+#include <regex>
+
 // TODO: Issue#2 - STL regex generates really bloated code.  Use POSIX regex
 //       interfaces instead.
-static const std::regex sensors_regex =
-    std::regex("^(fan|in|temp|power|energy|curr)([0-9]+)_([a-z]*)",
-               std::regex::extended);
+static const std::regex sensors_regex = std::regex(
+    "^(fan|in|temp|power|energy|curr)([0-9]+)_([a-z]*)", std::regex::extended);
 static const auto sensor_regex_match_count = 4;
 
 SensorSet::SensorSet(const std::string& path)
diff --git a/sensorset.hpp b/sensorset.hpp
index 420761f..8ad0d5a 100644
--- a/sensorset.hpp
+++ b/sensorset.hpp
@@ -19,58 +19,56 @@
  */
 class SensorSet
 {
-    public:
-        typedef std::map<std::pair<std::string, std::string>,
-                std::set<std::string>> container_t;
-        using mapped_type = container_t::mapped_type;
-        using key_type = container_t::key_type;
+  public:
+    typedef std::map<std::pair<std::string, std::string>, std::set<std::string>>
+        container_t;
+    using mapped_type = container_t::mapped_type;
+    using key_type = container_t::key_type;
 
-        /**
-         * @brief Constructor
-         * @details Builds a map of the hwmon sysfs files in the passed
-         *          in directory.
-         *
-         * @param[in] path - path to the hwmon device directory
-         *
-         */
-        explicit SensorSet(const std::string& path);
-        ~SensorSet() = default;
-        SensorSet() = delete;
-        SensorSet(const SensorSet&) = delete;
-        SensorSet& operator=(const SensorSet&) = delete;
-        SensorSet(SensorSet&&) = default;
-        SensorSet& operator=(SensorSet&&) = default;
+    /**
+     * @brief Constructor
+     * @details Builds a map of the hwmon sysfs files in the passed
+     *          in directory.
+     *
+     * @param[in] path - path to the hwmon device directory
+     *
+     */
+    explicit SensorSet(const std::string& path);
+    ~SensorSet() = default;
+    SensorSet() = delete;
+    SensorSet(const SensorSet&) = delete;
+    SensorSet& operator=(const SensorSet&) = delete;
+    SensorSet(SensorSet&&) = default;
+    SensorSet& operator=(SensorSet&&) = default;
 
-        /**
-         * @brief Returns an iterator to the beginning of the map
-         *
-         * @return const_iterator
-         */
-        container_t::const_iterator begin()
-        {
-            return const_cast<const container_t&>(container).begin();
-        }
+    /**
+     * @brief Returns an iterator to the beginning of the map
+     *
+     * @return const_iterator
+     */
+    container_t::const_iterator begin()
+    {
+        return const_cast<const container_t&>(container).begin();
+    }
 
-        /**
-         * @brief Returns an iterator to the end of the map
-         *
-         * @return const_iterator
-         */
-        container_t::const_iterator end()
-        {
-            return const_cast<const container_t&>(container).end();
-        }
+    /**
+     * @brief Returns an iterator to the end of the map
+     *
+     * @return const_iterator
+     */
+    container_t::const_iterator end()
+    {
+        return const_cast<const container_t&>(container).end();
+    }
 
-    private:
-
-        /**
-         * @brief The map of hwmon files in the directory
-         * @details For example:
-         *          key = pair("temp", "1")
-         *          value = "input"
-         */
-        container_t container;
-
+  private:
+    /**
+     * @brief The map of hwmon files in the directory
+     * @details For example:
+     *          key = pair("temp", "1")
+     *          value = "input"
+     */
+    container_t container;
 };
 
 // vim: tabstop=8 expandtab shiftwidth=4 softtabstop=4
diff --git a/sysfs.cpp b/sysfs.cpp
index d7ad3a2..dd711e5 100644
--- a/sysfs.cpp
+++ b/sysfs.cpp
@@ -13,6 +13,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include "config.h"
+
+#include "sysfs.hpp"
+
 #include <algorithm>
 #include <cerrno>
 #include <cstdlib>
@@ -21,20 +25,18 @@
 #include <memory>
 #include <phosphor-logging/log.hpp>
 #include <thread>
-#include "config.h"
-#include "sysfs.hpp"
 
 using namespace std::string_literals;
 namespace fs = std::experimental::filesystem;
 
-namespace sysfs {
+namespace sysfs
+{
 
 static const auto emptyString = ""s;
 static constexpr auto ofRoot = "/sys/firmware/devicetree/base";
 
-std::string findPhandleMatch(
-        const std::string& iochanneldir,
-        const std::string& phandledir)
+std::string findPhandleMatch(const std::string& iochanneldir,
+                             const std::string& phandledir)
 {
     // TODO: At the moment this method only supports device trees
     // with iio-hwmon nodes with a single sensor.  Typically
@@ -56,9 +58,8 @@
     uint32_t ioChannelsValue;
     std::ifstream ioChannelsFile(ioChannelsPath);
 
-    ioChannelsFile.read(
-            reinterpret_cast<char*>(&ioChannelsValue),
-            sizeof(ioChannelsValue));
+    ioChannelsFile.read(reinterpret_cast<char*>(&ioChannelsValue),
+                        sizeof(ioChannelsValue));
 
     for (const auto& ofInst : fs::recursive_directory_iterator(phandledir))
     {
@@ -70,9 +71,8 @@
         std::ifstream pHandleFile(path);
         uint32_t pHandleValue;
 
-        pHandleFile.read(
-                reinterpret_cast<char*>(&pHandleValue),
-                sizeof(pHandleValue));
+        pHandleFile.read(reinterpret_cast<char*>(&pHandleValue),
+                         sizeof(pHandleValue));
 
         if (ioChannelsValue == pHandleValue)
         {
@@ -128,7 +128,7 @@
     // If a match is found, use the corresponding /sys/devices
     // iio device as the callout device.
     static constexpr auto iioDevices = "/sys/bus/iio/devices";
-    for (const auto& iioDev: fs::recursive_directory_iterator(iioDevices))
+    for (const auto& iioDev : fs::recursive_directory_iterator(iioDevices))
     {
         p = iioDev.path();
         p /= "of_node";
@@ -211,9 +211,9 @@
 
     try
     {
-        //This path is also used as a filesystem path to an environment
-        //file, and that has issues with ':'s in the path so they've
-        //been converted to '--'s.  Convert them back now.
+        // This path is also used as a filesystem path to an environment
+        // file, and that has issues with ':'s in the path so they've
+        // been converted to '--'s.  Convert them back now.
         size_t pos = 0;
         std::string path = p;
         while ((pos = path.find("--")) != std::string::npos)
@@ -224,7 +224,7 @@
         for (const auto& hwmonInst : fs::directory_iterator(path))
         {
             if ((hwmonInst.path().filename().string().find("hwmon") !=
-                   std::string::npos))
+                 std::string::npos))
             {
                 return hwmonInst.path();
             }
@@ -233,9 +233,8 @@
     catch (const std::exception& e)
     {
         using namespace phosphor::logging;
-        log<level::ERR>(
-                "Unable to find hwmon directory from the dev path",
-                entry("PATH=%s", devPath.c_str()));
+        log<level::ERR>("Unable to find hwmon directory from the dev path",
+                        entry("PATH=%s", devPath.c_str()));
     }
     return emptyString;
 }
diff --git a/sysfs.hpp b/sysfs.hpp
index 10ab28d..c1799f6 100644
--- a/sysfs.hpp
+++ b/sysfs.hpp
@@ -5,7 +5,8 @@
 #include <fstream>
 #include <string>
 
-namespace sysfs {
+namespace sysfs
+{
 
 inline std::string make_sysfs_path(const std::string& path,
                                    const std::string& type,
@@ -14,7 +15,8 @@
 {
     using namespace std::literals;
 
-    if (entry.empty()) {
+    if (entry.empty())
+    {
         return path + "/"s + type + id;
     }
 
@@ -35,9 +37,8 @@
  *
  *  @return Path to phandle file with value matching that in io-channels
  */
-std::string findPhandleMatch(
-        const std::string& iochanneldir,
-        const std::string& phandledir);
+std::string findPhandleMatch(const std::string& iochanneldir,
+                             const std::string& phandledir);
 
 /** @brief Find hwmon instances from an open-firmware device tree path
  *
diff --git a/targets.hpp b/targets.hpp
index 9867ba9..317eec5 100644
--- a/targets.hpp
+++ b/targets.hpp
@@ -1,14 +1,15 @@
 #pragma once
 
+#include "env.hpp"
+#include "fan_pwm.hpp"
+#include "fan_speed.hpp"
+#include "hwmonio.hpp"
+
 #include <experimental/filesystem>
 #include <memory>
 #include <phosphor-logging/elog-errors.hpp>
 #include <phosphor-logging/log.hpp>
 #include <xyz/openbmc_project/Sensor/Device/error.hpp>
-#include "env.hpp"
-#include "fan_speed.hpp"
-#include "fan_pwm.hpp"
-#include "hwmonio.hpp"
 
 enum class targetType
 {
@@ -64,8 +65,7 @@
 template <typename T>
 std::shared_ptr<T> addTarget(const SensorSet::key_type& sensor,
                              const hwmonio::HwmonIO& ioAccess,
-                             const std::string& devPath,
-                             ObjectInfo& info)
+                             const std::string& devPath, ObjectInfo& info)
 {
     std::shared_ptr<T> target;
     namespace fs = std::experimental::filesystem;
@@ -98,10 +98,8 @@
         entry = empty;
     }
 
-    sysfsFullPath = sysfs::make_sysfs_path(ioAccess.path(),
-                                           targetName,
-                                           targetId,
-                                           entry);
+    sysfsFullPath =
+        sysfs::make_sysfs_path(ioAccess.path(), targetName, targetId, entry);
     if (fs::exists(sysfsFullPath))
     {
         auto useTarget = true;
@@ -128,11 +126,10 @@
             else
             {
                 using namespace phosphor::logging;
-                log<level::ERR>("Invalid TARGET_MODE env var found",
-                        phosphor::logging::entry(
-                                "TARGET_MODE=%s", tmEnv.c_str()),
-                        phosphor::logging::entry(
-                                "DEVPATH=%s", devPath.c_str()));
+                log<level::ERR>(
+                    "Invalid TARGET_MODE env var found",
+                    phosphor::logging::entry("TARGET_MODE=%s", tmEnv.c_str()),
+                    phosphor::logging::entry("DEVPATH=%s", devPath.c_str()));
             }
         }
 
@@ -142,40 +139,31 @@
 
             try
             {
-                targetSpeed = ioAccess.read(
-                    targetName,
-                    targetId,
-                    entry,
-                    hwmonio::retries,
-                    hwmonio::delay);
+                targetSpeed = ioAccess.read(targetName, targetId, entry,
+                                            hwmonio::retries, hwmonio::delay);
             }
             catch (const std::system_error& e)
             {
                 using namespace phosphor::logging;
-                using namespace sdbusplus::xyz::openbmc_project::
-                    Sensor::Device::Error;
-                using metadata = xyz::openbmc_project::Sensor::
-                    Device::ReadFailure;
+                using namespace sdbusplus::xyz::openbmc_project::Sensor::
+                    Device::Error;
+                using metadata =
+                    xyz::openbmc_project::Sensor::Device::ReadFailure;
 
                 report<ReadFailure>(
-                        metadata::CALLOUT_ERRNO(e.code().value()),
-                        metadata::CALLOUT_DEVICE_PATH(devPath.c_str()));
+                    metadata::CALLOUT_ERRNO(e.code().value()),
+                    metadata::CALLOUT_DEVICE_PATH(devPath.c_str()));
 
-                log<level::INFO>("Logging failing sysfs file",
-                        phosphor::logging::entry(
-                                "FILE=%s", sysfsFullPath.c_str()));
+                log<level::INFO>(
+                    "Logging failing sysfs file",
+                    phosphor::logging::entry("FILE=%s", sysfsFullPath.c_str()));
             }
 
             // ioAccess.path() is a path like: /sys/class/hwmon/hwmon1
             target = std::make_shared<T>(
-                    std::move(std::make_unique<hwmonio::HwmonIO>(
-                            ioAccess.path())),
-                    devPath,
-                    targetId,
-                    bus,
-                    objPath.c_str(),
-                    deferSignals,
-                    targetSpeed);
+                std::move(std::make_unique<hwmonio::HwmonIO>(ioAccess.path())),
+                devPath, targetId, bus, objPath.c_str(), deferSignals,
+                targetSpeed);
             obj[type] = target;
         }
     }
diff --git a/test/fanpwm_unittest.cpp b/test/fanpwm_unittest.cpp
index 63520d3..11dcee9 100644
--- a/test/fanpwm_unittest.cpp
+++ b/test/fanpwm_unittest.cpp
@@ -1,11 +1,11 @@
 #include "fan_pwm.hpp"
-
 #include "hwmonio_mock.hpp"
 
+#include <sdbusplus/test/sdbus_mock.hpp>
+#include <string>
+
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
-#include <sdbusplus/test/sdbus_mock.hpp>
-#include <string>
 
 using ::testing::_;
 using ::testing::Invoke;
@@ -19,55 +19,38 @@
 
 // Handle basic expectations we'll need for all these tests, if it's found that
 // this is helpful for more tests, it can be promoted in scope.
-void SetupDbusObject(
-        sdbusplus::SdBusMock *sdbus_mock,
-        const std::string& path,
-        const std::string& intf,
-        const std::string property = "")
+void SetupDbusObject(sdbusplus::SdBusMock *sdbus_mock, const std::string &path,
+                     const std::string &intf, const std::string property = "")
 {
     EXPECT_CALL(*sdbus_mock,
-                sd_bus_add_object_vtable(
-                    IsNull(),
-                    NotNull(),
-                    StrEq(path),
-                    StrEq(intf),
-                    NotNull(),
-                    NotNull()))
-    .WillOnce(Return(0));
+                sd_bus_add_object_vtable(IsNull(), NotNull(), StrEq(path),
+                                         StrEq(intf), NotNull(), NotNull()))
+        .WillOnce(Return(0));
 
     if (property.empty())
     {
         EXPECT_CALL(*sdbus_mock,
-                    sd_bus_emit_properties_changed_strv(
-                        IsNull(),
-                        StrEq(path),
-                        StrEq(intf),
-                        NotNull()))
-        .WillOnce(Return(0));
+                    sd_bus_emit_properties_changed_strv(IsNull(), StrEq(path),
+                                                        StrEq(intf), NotNull()))
+            .WillOnce(Return(0));
     }
     else
     {
         EXPECT_CALL(*sdbus_mock,
-                    sd_bus_emit_properties_changed_strv(
-                        IsNull(),
-                        StrEq(path),
-                        StrEq(intf),
-                        NotNull()))
-        .WillOnce(
-            Invoke([=](sd_bus *bus,
-                       const char *path,
-                       const char *interface,
-                       char **names) {
+                    sd_bus_emit_properties_changed_strv(IsNull(), StrEq(path),
+                                                        StrEq(intf), NotNull()))
+            .WillOnce(Invoke([=](sd_bus *bus, const char *path,
+                                 const char *interface, char **names) {
                 EXPECT_STREQ(property.c_str(), names[0]);
                 return 0;
-            })
-        );
+            }));
     }
 
     return;
 }
 
-TEST(FanPwmTest, BasicConstructorDeferredTest) {
+TEST(FanPwmTest, BasicConstructorDeferredTest)
+{
     // Attempt to just instantiate one.
 
     // NOTE: This test's goal is to figure out what's minimally required to
@@ -87,16 +70,12 @@
 
     SetupDbusObject(&sdbus_mock, objPath, FanPwmIntf, FanPwmProp);
 
-    hwmon::FanPwm f(std::move(hwmonio_mock),
-                    devPath,
-                    id,
-                    bus_mock,
-                    objPath.c_str(),
-                    defer,
-                    target);
+    hwmon::FanPwm f(std::move(hwmonio_mock), devPath, id, bus_mock,
+                    objPath.c_str(), defer, target);
 }
 
-TEST(FanPwmTest, BasicConstructorNotDeferredTest) {
+TEST(FanPwmTest, BasicConstructorNotDeferredTest)
+{
     // Attempt to just instantiate one.
 
     // NOTE: This test's goal is to figure out what's minimally required to
@@ -116,24 +95,18 @@
 
     SetupDbusObject(&sdbus_mock, objPath, FanPwmIntf, FanPwmProp);
 
-    EXPECT_CALL(sdbus_mock,
-                sd_bus_emit_object_added(IsNull(), StrEq("asdf")))
-    .WillOnce(Return(0));
+    EXPECT_CALL(sdbus_mock, sd_bus_emit_object_added(IsNull(), StrEq("asdf")))
+        .WillOnce(Return(0));
 
-    EXPECT_CALL(sdbus_mock,
-                sd_bus_emit_object_removed(IsNull(), StrEq("asdf")))
-    .WillOnce(Return(0));
+    EXPECT_CALL(sdbus_mock, sd_bus_emit_object_removed(IsNull(), StrEq("asdf")))
+        .WillOnce(Return(0));
 
-    hwmon::FanPwm f(std::move(hwmonio_mock),
-                    devPath,
-                    id,
-                    bus_mock,
-                    objPath.c_str(),
-                    defer,
-                    target);
+    hwmon::FanPwm f(std::move(hwmonio_mock), devPath, id, bus_mock,
+                    objPath.c_str(), defer, target);
 }
 
-TEST(FanPwmTest, WriteTargetValue) {
+TEST(FanPwmTest, WriteTargetValue)
+{
     // Create a FanPwm and write a value to the object.
 
     sdbusplus::SdBusMock sdbus_mock;
@@ -154,43 +127,29 @@
     hwmonio::HwmonIOMock *hwmonio =
         reinterpret_cast<hwmonio::HwmonIOMock *>(hwmonio_mock.get());
 
-    hwmon::FanPwm f(std::move(hwmonio_mock),
-                    devPath,
-                    id,
-                    bus_mock,
-                    objPath.c_str(),
-                    defer,
-                    target);
+    hwmon::FanPwm f(std::move(hwmonio_mock), devPath, id, bus_mock,
+                    objPath.c_str(), defer, target);
 
     target = 0x64;
 
-    EXPECT_CALL(*hwmonio, write(static_cast<uint32_t>(target),
-                                StrEq("pwm"),
-                                StrEq("the_id"),
-                                _,
-                                hwmonio::retries,
-                                hwmonio::delay));
+    EXPECT_CALL(*hwmonio,
+                write(static_cast<uint32_t>(target), StrEq("pwm"),
+                      StrEq("the_id"), _, hwmonio::retries, hwmonio::delay));
 
     EXPECT_CALL(sdbus_mock,
                 sd_bus_emit_properties_changed_strv(
-                    IsNull(),
-                    StrEq("asdf"),
-                    StrEq(FanPwmIntf),
-                    NotNull()))
-    .WillOnce(
-        Invoke([&](sd_bus *bus,
-                   const char *path,
-                   const char *interface,
-                   char **names) {
+                    IsNull(), StrEq("asdf"), StrEq(FanPwmIntf), NotNull()))
+        .WillOnce(Invoke([&](sd_bus *bus, const char *path,
+                             const char *interface, char **names) {
             EXPECT_EQ(0, strncmp("Target", names[0], 6));
             return 0;
-        })
-    );
+        }));
 
     EXPECT_EQ(target, f.target(target));
 }
 
-TEST(FanPwmTest, WriteTargetValueNoUpdate) {
+TEST(FanPwmTest, WriteTargetValueNoUpdate)
+{
     // Create a FanPwm and write a value to the object that was the previous
     // value.
 
@@ -209,13 +168,8 @@
 
     SetupDbusObject(&sdbus_mock, objPath, FanPwmIntf, FanPwmProp);
 
-    hwmon::FanPwm f(std::move(hwmonio_mock),
-                    devPath,
-                    id,
-                    bus_mock,
-                    objPath.c_str(),
-                    defer,
-                    target);
+    hwmon::FanPwm f(std::move(hwmonio_mock), devPath, id, bus_mock,
+                    objPath.c_str(), defer, target);
 
     EXPECT_EQ(target, f.target(target));
 }
diff --git a/test/hwmon_unittest.cpp b/test/hwmon_unittest.cpp
index 035d098..1c538c7 100644
--- a/test/hwmon_unittest.cpp
+++ b/test/hwmon_unittest.cpp
@@ -3,10 +3,9 @@
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
-TEST(HwmonTest, InvalidType) {
+TEST(HwmonTest, InvalidType)
+{
 
-  hwmon::Attributes attrs;
-  EXPECT_FALSE(hwmon::getAttributes("invalid", attrs));
-
+    hwmon::Attributes attrs;
+    EXPECT_FALSE(hwmon::getAttributes("invalid", attrs));
 }
-
diff --git a/test/hwmonio_mock.hpp b/test/hwmonio_mock.hpp
index 4ad944c..6caa67e 100644
--- a/test/hwmonio_mock.hpp
+++ b/test/hwmonio_mock.hpp
@@ -1,30 +1,26 @@
 #pragma once
 
-#include <gmock/gmock.h>
-
 #include "hwmonio.hpp"
 
-namespace hwmonio {
+#include <gmock/gmock.h>
+
+namespace hwmonio
+{
 
 class HwmonIOMock : public HwmonIOInterface
 {
-    public:
-        virtual ~HwmonIOMock(){};
+  public:
+    virtual ~HwmonIOMock(){};
 
-        MOCK_CONST_METHOD5(read, int64_t(const std::string&,
-                                         const std::string&,
-                                         const std::string&,
-                                         size_t,
-                                         std::chrono::milliseconds));
+    MOCK_CONST_METHOD5(read, int64_t(const std::string&, const std::string&,
+                                     const std::string&, size_t,
+                                     std::chrono::milliseconds));
 
-        MOCK_CONST_METHOD6(write, void(uint32_t,
-                                       const std::string&,
-                                       const std::string&,
-                                       const std::string&,
-                                       size_t,
-                                       std::chrono::milliseconds));
+    MOCK_CONST_METHOD6(write, void(uint32_t, const std::string&,
+                                   const std::string&, const std::string&,
+                                   size_t, std::chrono::milliseconds));
 
-        MOCK_CONST_METHOD0(path, std::string());
+    MOCK_CONST_METHOD0(path, std::string());
 };
 
 } // namespace hwmonio
diff --git a/thresholds.hpp b/thresholds.hpp
index 684e712..c483665 100644
--- a/thresholds.hpp
+++ b/thresholds.hpp
@@ -59,8 +59,7 @@
 template <typename T>
 void checkThresholds(std::experimental::any& iface, int64_t value)
 {
-    auto realIface = std::experimental::any_cast<std::shared_ptr<T>>
-                     (iface);
+    auto realIface = std::experimental::any_cast<std::shared_ptr<T>>(iface);
     auto lo = (*realIface.*Thresholds<T>::getLo)();
     auto hi = (*realIface.*Thresholds<T>::getHi)();
     (*realIface.*Thresholds<T>::alarmLo)(value <= lo);
@@ -80,10 +79,8 @@
  *  @param[in] info - The sdbusplus server connection and interfaces.
  */
 template <typename T>
-auto addThreshold(const std::string& sensorType,
-                  const std::string& sensorID,
-                  int64_t value,
-                  ObjectInfo& info)
+auto addThreshold(const std::string& sensorType, const std::string& sensorID,
+                  int64_t value, ObjectInfo& info)
 {
     static constexpr bool deferSignals = true;
 
diff --git a/timer.cpp b/timer.cpp
index 973b012..a99ec46 100644
--- a/timer.cpp
+++ b/timer.cpp
@@ -1,7 +1,9 @@
+#include "timer.hpp"
+
+#include <string.h>
+
 #include <chrono>
 #include <system_error>
-#include <string.h>
-#include "timer.hpp"
 
 namespace phosphor
 {
@@ -15,36 +17,32 @@
     return duration_cast<microseconds>(usec);
 }
 
-Timer::Timer(sd_event* event,
-             std::function<void()> callback,
-             std::chrono::microseconds usec,
-             timer::Action action):
+Timer::Timer(sd_event* event, std::function<void()> callback,
+             std::chrono::microseconds usec, timer::Action action) :
     event(event),
-    callback(callback),
-    duration(usec),
-    action(action)
+    callback(callback), duration(usec), action(action)
 {
     auto r = sd_event_add_time(event, &eventSource,
-                               CLOCK_MONOTONIC, // Time base
+                               CLOCK_MONOTONIC,            // Time base
                                (getTime() + usec).count(), // When to fire
-                               0, // Use default event accuracy
+                               0,              // Use default event accuracy
                                timeoutHandler, // Callback handler on timeout
-                               this); // User data
+                               this);          // User data
     if (r < 0)
     {
         throw std::system_error(r, std::generic_category(), strerror(-r));
     }
 }
 
-int Timer::timeoutHandler(sd_event_source* eventSource,
-                          uint64_t usec, void* userData)
+int Timer::timeoutHandler(sd_event_source* eventSource, uint64_t usec,
+                          void* userData)
 {
     auto timer = static_cast<Timer*>(userData);
 
     if (timer->getAction() == timer::ON)
     {
         auto r = sd_event_source_set_time(
-                     eventSource, (getTime() + timer->getDuration()).count());
+            eventSource, (getTime() + timer->getDuration()).count());
         if (r < 0)
         {
             throw std::system_error(r, std::generic_category(), strerror(-r));
@@ -56,7 +54,7 @@
         }
     }
 
-    if(timer->callback)
+    if (timer->callback)
     {
         timer->callback();
     }
diff --git a/timer.hpp b/timer.hpp
index bb1d6e9..03f642d 100644
--- a/timer.hpp
+++ b/timer.hpp
@@ -1,8 +1,9 @@
 #pragma once
 
+#include <systemd/sd-event.h>
+
 #include <chrono>
 #include <functional>
-#include <systemd/sd-event.h>
 
 namespace phosphor
 {
@@ -17,7 +18,6 @@
     ON = SD_EVENT_ON,
     ONESHOT = SD_EVENT_ONESHOT
 };
-
 }
 
 /** @class Timer
@@ -32,76 +32,74 @@
  */
 class Timer
 {
-    public:
-        Timer() = delete;
-        Timer(const Timer&) = delete;
-        Timer& operator=(const Timer&) = delete;
-        Timer(Timer&&) = delete;
-        Timer& operator=(Timer&&) = delete;
+  public:
+    Timer() = delete;
+    Timer(const Timer&) = delete;
+    Timer& operator=(const Timer&) = delete;
+    Timer(Timer&&) = delete;
+    Timer& operator=(Timer&&) = delete;
 
-        /** @brief Constructs timer object
-         *
-         *  @param[in] events - sd_event pointer
-         *  @param[in] callback - function callback for timer expiry
-         *  @param[in] usec - timer duration, in micro seconds
-         *  @param[in] action - controls the timer's lifetime
-         */
-        Timer(sd_event* event,
-              std::function<void()> userCallback,
-              std::chrono::microseconds usec,
-              timer::Action action);
+    /** @brief Constructs timer object
+     *
+     *  @param[in] events - sd_event pointer
+     *  @param[in] callback - function callback for timer expiry
+     *  @param[in] usec - timer duration, in micro seconds
+     *  @param[in] action - controls the timer's lifetime
+     */
+    Timer(sd_event* event, std::function<void()> userCallback,
+          std::chrono::microseconds usec, timer::Action action);
 
-        ~Timer()
+    ~Timer()
+    {
+        if (eventSource)
         {
-            if (eventSource)
-            {
-                eventSource = sd_event_source_unref(eventSource);
-            }
+            eventSource = sd_event_source_unref(eventSource);
         }
+    }
 
-        /** @brief Timer expiry handler - invokes callback
-         *
-         *  @param[in] eventSource - Source of the event
-         *  @param[in] usec        - time in micro seconds
-         *  @param[in] userData    - User data pointer
-         *
-         */
-        static int timeoutHandler(sd_event_source* eventSource,
-                                  uint64_t usec, void* userData);
+    /** @brief Timer expiry handler - invokes callback
+     *
+     *  @param[in] eventSource - Source of the event
+     *  @param[in] usec        - time in micro seconds
+     *  @param[in] userData    - User data pointer
+     *
+     */
+    static int timeoutHandler(sd_event_source* eventSource, uint64_t usec,
+                              void* userData);
 
-        /** @brief Enables / disables the timer
-         *  @param[in] action - controls the timer's lifetime
-         */
-        int state(timer::Action action)
-        {
-            return sd_event_source_set_enabled(eventSource, action);
-        }
+    /** @brief Enables / disables the timer
+     *  @param[in] action - controls the timer's lifetime
+     */
+    int state(timer::Action action)
+    {
+        return sd_event_source_set_enabled(eventSource, action);
+    }
 
-        timer::Action getAction() const
-        {
-            return action;
-        }
+    timer::Action getAction() const
+    {
+        return action;
+    }
 
-        std::chrono::microseconds getDuration() const
-        {
-            return duration;
-        }
+    std::chrono::microseconds getDuration() const
+    {
+        return duration;
+    }
 
-    private:
-        /** @brief the sd_event structure */
-        sd_event* event = nullptr;
+  private:
+    /** @brief the sd_event structure */
+    sd_event* event = nullptr;
 
-        /** @brief Source of events */
-        sd_event_source* eventSource = nullptr;
+    /** @brief Source of events */
+    sd_event_source* eventSource = nullptr;
 
-        /** @brief Optional function to call on timer expiration */
-        std::function<void()> callback{};
+    /** @brief Optional function to call on timer expiration */
+    std::function<void()> callback{};
 
-        /** @brief Duration of the timer */
-        std::chrono::microseconds duration{};
+    /** @brief Duration of the timer */
+    std::chrono::microseconds duration{};
 
-        /** @brief whether the timer is enabled/disabled/one-shot */
-        timer::Action action = timer::OFF;
+    /** @brief whether the timer is enabled/disabled/one-shot */
+    timer::Action action = timer::OFF;
 };
 
 } // namespace hwmon
diff --git a/tools/find_callout_path.cpp b/tools/find_callout_path.cpp
index 97280fc..f72673c 100644
--- a/tools/find_callout_path.cpp
+++ b/tools/find_callout_path.cpp
@@ -13,15 +13,15 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include <iostream>
 #include "../sysfs.hpp"
 
+#include <iostream>
+
 int main(int argc, char* argv[])
 {
     if (argc < 2)
     {
-        std::cerr << "Usage: " << argv[0]
-            << " HWMON_INST_PATH" << std::endl;
+        std::cerr << "Usage: " << argv[0] << " HWMON_INST_PATH" << std::endl;
         return 1;
     }
 
diff --git a/tools/find_hwmon.cpp b/tools/find_hwmon.cpp
index 1142ad1..f155541 100644
--- a/tools/find_hwmon.cpp
+++ b/tools/find_hwmon.cpp
@@ -13,15 +13,15 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include <iostream>
 #include "../sysfs.hpp"
 
+#include <iostream>
+
 int main(int argc, char* argv[])
 {
     if (argc < 2)
     {
-        std::cerr << "Usage: " << argv[0]
-            << " DT_REL_BASE_PATH" << std::endl;
+        std::cerr << "Usage: " << argv[0] << " DT_REL_BASE_PATH" << std::endl;
         return 1;
     }
 
diff --git a/types.hpp b/types.hpp
index 5d12e8c..a33869c 100644
--- a/types.hpp
+++ b/types.hpp
@@ -1,8 +1,9 @@
 #pragma once
 
-#include <experimental/any>
 #include "interface.hpp"
 
+#include <experimental/any>
+
 using Object = std::map<InterfaceType, std::experimental::any>;
 using ObjectInfo = std::tuple<sdbusplus::bus::bus*, std::string, Object>;
 using RetryIO = std::tuple<size_t, std::chrono::milliseconds>;