style: member functions should be lower camel

Rename member functions to be lower camel instead of snake case.

Change-Id: Ib227fd3dadb6d9607290277205223a4324cd4ce5
Signed-off-by: Patrick Venture <venture@google.com>

13 files changed, 59 insertions, 59 deletions

diff --git a/pid/builder.cpp b/pid/builder.cpp
index fece41b..7b67795 100644
--- a/pid/builder.cpp
+++ b/pid/builder.cpp
@@ -90,7 +90,7 @@ std::unordered_map<int64_t, std::unique_ptr<PIDZone>>
                     zone->addFanInput(i);
                 }
 
-                auto pid = FanController::CreateFanPid(zone.get(), name, inputs,
+                auto pid = FanController::createFanPid(zone.get(), name, inputs,
                                                        info->pidInfo);
                 zone->addFanPID(std::move(pid));
             }
@@ -102,7 +102,7 @@ std::unordered_map<int64_t, std::unique_ptr<PIDZone>>
                     zone->addThermalInput(i);
                 }
 
-                auto pid = ThermalController::CreateThermalPid(
+                auto pid = ThermalController::createThermalPid(
                     zone.get(), name, inputs, info->setpoint, info->pidInfo);
 
                 zone->addThermalPID(std::move(pid));
@@ -114,7 +114,7 @@ std::unordered_map<int64_t, std::unique_ptr<PIDZone>>
                     inputs.push_back(i);
                     zone->addThermalInput(i);
                 }
-                auto stepwise = StepwiseController::CreateStepwiseController(
+                auto stepwise = StepwiseController::createStepwiseController(
                     zone.get(), name, inputs, info->stepwiseInfo);
                 zone->addThermalPID(std::move(stepwise));
             }
diff --git a/pid/controller.hpp b/pid/controller.hpp
index f52c412..bf79937 100644
--- a/pid/controller.hpp
+++ b/pid/controller.hpp
@@ -7,7 +7,7 @@
 
 /*
  * Base class for controllers.  Each controller that implements this needs to
- * provide an input_proc, process, and output_proc.
+ * provide an inputProc, process, and outputProc.
  */
 class ZoneInterface;
 
@@ -15,11 +15,11 @@ struct Controller
 {
     virtual ~Controller() = default;
 
-    virtual float input_proc(void) = 0;
+    virtual float inputProc(void) = 0;
 
-    virtual void output_proc(float value) = 0;
+    virtual void outputProc(float value) = 0;
 
     virtual void process(void) = 0;
 
-    virtual std::string get_id(void) = 0;
+    virtual std::string getID(void) = 0;
 };
diff --git a/pid/fancontroller.cpp b/pid/fancontroller.cpp
index f622698..3a56f95 100644
--- a/pid/fancontroller.cpp
+++ b/pid/fancontroller.cpp
@@ -23,7 +23,7 @@
 #include <iostream>
 
 std::unique_ptr<PIDController>
-    FanController::CreateFanPid(ZoneInterface* owner, const std::string& id,
+    FanController::createFanPid(ZoneInterface* owner, const std::string& id,
                                 const std::vector<std::string>& inputs,
                                 const ec::pidinfo& initial)
 {
@@ -32,14 +32,14 @@ std::unique_ptr<PIDController>
         return nullptr;
     }
     auto fan = std::make_unique<FanController>(id, inputs, owner);
-    ec::pid_info_t* info = fan->get_pid_info();
+    ec::pid_info_t* info = fan->getPIDInfo();
 
     InitializePIDStruct(info, initial);
 
     return fan;
 }
 
-float FanController::input_proc(void)
+float FanController::inputProc(void)
 {
     double value = 0;
     std::vector<int64_t> values;
@@ -66,7 +66,7 @@ float FanController::input_proc(void)
     }
     catch (const std::exception& e)
     {
-        std::cerr << "exception on input_proc.\n";
+        std::cerr << "exception on inputProc.\n";
         throw;
     }
 
@@ -85,12 +85,12 @@ float FanController::input_proc(void)
     return static_cast<float>(value);
 }
 
-float FanController::setpt_proc(void)
+float FanController::setptProc(void)
 {
     float maxRPM = _owner->getMaxRPMRequest();
 
     // store for reference, and check if more or less.
-    float prev = get_setpoint();
+    float prev = getSetpoint();
 
     if (maxRPM > prev)
     {
@@ -105,12 +105,12 @@ float FanController::setpt_proc(void)
         setFanDirection(FanSpeedDirection::NEUTRAL);
     }
 
-    set_setpoint(maxRPM);
+    setSetpoint(maxRPM);
 
     return (maxRPM);
 }
 
-void FanController::output_proc(float value)
+void FanController::outputProc(float value)
 {
     float percent = value;
 
diff --git a/pid/fancontroller.hpp b/pid/fancontroller.hpp
index e0e79e7..821c900 100644
--- a/pid/fancontroller.hpp
+++ b/pid/fancontroller.hpp
@@ -17,7 +17,7 @@ class FanController : public PIDController
 {
   public:
     static std::unique_ptr<PIDController>
-        CreateFanPid(ZoneInterface* owner, const std::string& id,
+        createFanPid(ZoneInterface* owner, const std::string& id,
                      const std::vector<std::string>& inputs,
                      const ec::pidinfo& initial);
 
@@ -28,9 +28,9 @@ class FanController : public PIDController
     {
     }
 
-    float input_proc(void) override;
-    float setpt_proc(void) override;
-    void output_proc(float value) override;
+    float inputProc(void) override;
+    float setptProc(void) override;
+    void outputProc(float value) override;
 
     FanSpeedDirection getFanDirection(void) const
     {
diff --git a/pid/pidcontroller.cpp b/pid/pidcontroller.cpp
index 524b0ef..cbe2452 100644
--- a/pid/pidcontroller.cpp
+++ b/pid/pidcontroller.cpp
@@ -33,16 +33,16 @@ void PIDController::process(void)
     float output;
 
     // Get setpt value
-    setpt = setpt_proc();
+    setpt = setptProc();
 
     // Get input value
-    input = input_proc();
+    input = inputProc();
 
     // Calculate new output
-    output = ec::pid(get_pid_info(), input, setpt);
+    output = ec::pid(getPIDInfo(), input, setpt);
 
     // Output new value
-    output_proc(output);
+    outputProc(output);
 
     return;
 }
diff --git a/pid/pidcontroller.hpp b/pid/pidcontroller.hpp
index 18a448e..9c3ee7f 100644
--- a/pid/pidcontroller.hpp
+++ b/pid/pidcontroller.hpp
@@ -11,7 +11,7 @@ class ZoneInterface;
 
 /*
  * Base class for PID controllers.  Each PID that implements this needs to
- * provide an input_proc, setpt_proc, and output_proc.
+ * provide an inputProc, setptProc, and outputProc.
  */
 class PIDController : public Controller
 {
@@ -25,26 +25,26 @@ class PIDController : public Controller
     {
     }
 
-    virtual float input_proc(void) = 0;
-    virtual float setpt_proc(void) = 0;
-    virtual void output_proc(float value) = 0;
+    virtual float inputProc(void) = 0;
+    virtual float setptProc(void) = 0;
+    virtual void outputProc(float value) = 0;
 
     void process(void);
 
-    std::string get_id(void)
+    std::string getID(void)
     {
         return _id;
     }
-    float get_setpoint(void)
+    float getSetpoint(void)
     {
         return _setpoint;
     }
-    void set_setpoint(float setpoint)
+    void setSetpoint(float setpoint)
     {
         _setpoint = setpoint;
     }
 
-    ec::pid_info_t* get_pid_info(void)
+    ec::pid_info_t* getPIDInfo(void)
     {
         return &_pid_info;
     }
diff --git a/pid/pidthread.cpp b/pid/pidthread.cpp
index 4dfc22a..dc53bdb 100644
--- a/pid/pidthread.cpp
+++ b/pid/pidthread.cpp
@@ -32,7 +32,7 @@ static void ProcessThermals(PIDZone* zone)
     // Zero out the RPM set point goals.
     zone->clearRPMSetPoints();
     // Run the margin PIDs.
-    zone->process_thermals();
+    zone->processThermals();
     // Get the maximum RPM set-point.
     zone->determineMaxRPMRequest();
 }
@@ -60,7 +60,7 @@ void PIDControlThread(PIDZone* zone)
      * will happen.
      *
      * TODO(venture): If the fan value is 0 should that loop just be skipped?
-     * Right now, a 0 value is ignored in FanController::input_proc()
+     * Right now, a 0 value is ignored in FanController::inputProc()
      */
 #ifdef __TUNING_LOGGING__
     zone->initializeLog();
@@ -90,7 +90,7 @@ void PIDControlThread(PIDZone* zone)
         }
 
         // Run the fan PIDs every iteration.
-        zone->process_fans();
+        zone->processFans();
 
 #ifdef __TUNING_LOGGING__
         zone->getLogHandle() << "," << zone->getFailSafeMode();
diff --git a/pid/stepwisecontroller.cpp b/pid/stepwisecontroller.cpp
index 1e6c301..875a470 100644
--- a/pid/stepwisecontroller.cpp
+++ b/pid/stepwisecontroller.cpp
@@ -32,7 +32,7 @@
 void StepwiseController::process(void)
 {
     // Get input value
-    float input = input_proc();
+    float input = inputProc();
 
     ec::StepwiseInfo info = get_stepwise_info();
 
@@ -57,12 +57,12 @@ void StepwiseController::process(void)
 
     lastOutput = output;
     // Output new value
-    output_proc(output);
+    outputProc(output);
 
     return;
 }
 
-std::unique_ptr<Controller> StepwiseController::CreateStepwiseController(
+std::unique_ptr<Controller> StepwiseController::createStepwiseController(
     ZoneInterface* owner, const std::string& id,
     const std::vector<std::string>& inputs, const ec::StepwiseInfo& initial)
 {
@@ -81,13 +81,13 @@ std::unique_ptr<Controller> StepwiseController::CreateStepwiseController(
     return thermal;
 }
 
-float StepwiseController::input_proc(void)
+float StepwiseController::inputProc(void)
 {
     double value = _owner->getCachedValue(_inputs.at(0));
     return static_cast<float>(value);
 }
 
-void StepwiseController::output_proc(float value)
+void StepwiseController::outputProc(float value)
 {
     _owner->addRPMSetPoint(value);
 
diff --git a/pid/stepwisecontroller.hpp b/pid/stepwisecontroller.hpp
index a6b7816..f369397 100644
--- a/pid/stepwisecontroller.hpp
+++ b/pid/stepwisecontroller.hpp
@@ -14,7 +14,7 @@ class StepwiseController : public Controller
 {
   public:
     static std::unique_ptr<Controller>
-        CreateStepwiseController(ZoneInterface* owner, const std::string& id,
+        createStepwiseController(ZoneInterface* owner, const std::string& id,
                                  const std::vector<std::string>& inputs,
                                  const ec::StepwiseInfo& initial);
 
@@ -26,13 +26,13 @@ class StepwiseController : public Controller
     {
     }
 
-    float input_proc(void) override;
+    float inputProc(void) override;
 
-    void output_proc(float value) override;
+    void outputProc(float value) override;
 
     void process(void) override;
 
-    std::string get_id(void)
+    std::string getID(void)
     {
         return _id;
     }
diff --git a/pid/thermalcontroller.cpp b/pid/thermalcontroller.cpp
index f9d1e11..cc6c1f9 100644
--- a/pid/thermalcontroller.cpp
+++ b/pid/thermalcontroller.cpp
@@ -19,7 +19,7 @@
 #include "util.hpp"
 #include "zone.hpp"
 
-std::unique_ptr<PIDController> ThermalController::CreateThermalPid(
+std::unique_ptr<PIDController> ThermalController::createThermalPid(
     ZoneInterface* owner, const std::string& id,
     const std::vector<std::string>& inputs, float setpoint,
     const ec::pidinfo& initial)
@@ -32,8 +32,8 @@ std::unique_ptr<PIDController> ThermalController::CreateThermalPid(
 
     auto thermal = std::make_unique<ThermalController>(id, inputs, owner);
 
-    ec::pid_info_t* info = thermal->get_pid_info();
-    thermal->set_setpoint(setpoint);
+    ec::pid_info_t* info = thermal->getPIDInfo();
+    thermal->setSetpoint(setpoint);
 
     InitializePIDStruct(info, initial);
 
@@ -41,7 +41,7 @@ std::unique_ptr<PIDController> ThermalController::CreateThermalPid(
 }
 
 // bmc_host_sensor_value_float
-float ThermalController::input_proc(void)
+float ThermalController::inputProc(void)
 {
     /*
      * This only supports one thermal input because it doesn't yet know how to
@@ -52,9 +52,9 @@ float ThermalController::input_proc(void)
 }
 
 // bmc_get_setpt
-float ThermalController::setpt_proc(void)
+float ThermalController::setptProc(void)
 {
-    float setpoint = get_setpoint();
+    float setpoint = getSetpoint();
 
     /* TODO(venture): Thermal setpoint invalid? */
 #if 0
@@ -71,7 +71,7 @@ float ThermalController::setpt_proc(void)
 }
 
 // bmc_set_pid_output
-void ThermalController::output_proc(float value)
+void ThermalController::outputProc(float value)
 {
     _owner->addRPMSetPoint(value);
 
diff --git a/pid/thermalcontroller.hpp b/pid/thermalcontroller.hpp
index 9b2da71..040b222 100644
--- a/pid/thermalcontroller.hpp
+++ b/pid/thermalcontroller.hpp
@@ -15,7 +15,7 @@ class ThermalController : public PIDController
 {
   public:
     static std::unique_ptr<PIDController>
-        CreateThermalPid(ZoneInterface* owner, const std::string& id,
+        createThermalPid(ZoneInterface* owner, const std::string& id,
                          const std::vector<std::string>& inputs, float setpoint,
                          const ec::pidinfo& initial);
 
@@ -27,9 +27,9 @@ class ThermalController : public PIDController
     {
     }
 
-    float input_proc(void) override;
-    float setpt_proc(void) override;
-    void output_proc(float value) override;
+    float inputProc(void) override;
+    float setptProc(void) override;
+    void outputProc(float value) override;
 
   private:
     std::vector<std::string> _inputs;
diff --git a/pid/zone.cpp b/pid/zone.cpp
index ab5cc8c..2af3307 100644
--- a/pid/zone.cpp
+++ b/pid/zone.cpp
@@ -246,7 +246,7 @@ void PIDZone::updateSensors(void)
     {
         auto sensor = _mgr.getSensor(t);
         ReadReturn r = sensor->read();
-        int64_t timeout = sensor->GetTimeout();
+        int64_t timeout = sensor->getTimeout();
 
         _cachedValuesByName[t] = r.value;
         tstamp then = r.updated;
@@ -308,7 +308,7 @@ void PIDZone::dumpCache(void)
     }
 }
 
-void PIDZone::process_fans(void)
+void PIDZone::processFans(void)
 {
     for (auto& p : _fans)
     {
@@ -316,7 +316,7 @@ void PIDZone::process_fans(void)
     }
 }
 
-void PIDZone::process_thermals(void)
+void PIDZone::processThermals(void)
 {
     for (auto& p : _thermals)
     {
diff --git a/pid/zone.hpp b/pid/zone.hpp
index 6d5f6cc..d2da92c 100644
--- a/pid/zone.hpp
+++ b/pid/zone.hpp
@@ -74,8 +74,8 @@ class PIDZone : public ZoneInterface, public ModeObject
     void updateSensors(void);
     void initializeCache(void);
     void dumpCache(void);
-    void process_fans(void);
-    void process_thermals(void);
+    void processFans(void);
+    void processThermals(void);
 
     void addFanPID(std::unique_ptr<Controller> pid);
     void addThermalPID(std::unique_ptr<Controller> pid);