Run clang-format on all files

Author: ReeceHumphreys

libs/mujoco/test_package/src/main.cpp

@@ -1,7 +1,9 @@
 #include <mujoco/mujoco.h>
 
 // Just checking that we can actually run a mujoco function
-int main(int argc, char** argv) {
-  auto res = mju_min(0, 1);
-  return res == 0 ? 0 : 1;
+int
+main(int argc, char** argv)
+{
+    auto res = mju_min(0, 1);
+    return res == 0 ? 0 : 1;
 }

src/architecture/_GeneralModuleFiles/sys_model.cpp

@@ -21,11 +21,13 @@
 #include "architecture/utilities/moduleIdGenerator/moduleIdGenerator.h"
 
 SysModel::SysModel()
-    : moduleID(ModuleIdGenerator::GetInstance()->checkoutModuleID())
-{}
+  : moduleID(ModuleIdGenerator::GetInstance()->checkoutModuleID())
+{
+}
 
-SysModel::SysModel(const SysModel &obj)
-    : ModelTag{obj.ModelTag},
-    RNGSeed{obj.RNGSeed},
-    moduleID{ModuleIdGenerator::GetInstance()->checkoutModuleID()}
-{}
+SysModel::SysModel(const SysModel& obj)
+  : ModelTag{ obj.ModelTag }
+  , RNGSeed{ obj.RNGSeed }
+  , moduleID{ ModuleIdGenerator::GetInstance()->checkoutModuleID() }
+{
+}

src/architecture/_GeneralModuleFiles/sys_model.h

@@ -21,13 +21,13 @@
 #define _SysModel_HH_
 
 #include <architecture/utilities/bskLogging.h>
-#include <string>
 #include <stdint.h>
+#include <string>
 
 /*! @brief Simulation System Model Class */
 class SysModel
 {
-public:
+  public:
     SysModel();
 
     /**
@@ -38,27 +38,26 @@ class SysModel
      *
      * @param obj The SysModel object to copy data from.
      */
-    SysModel(const SysModel &obj);
+    SysModel(const SysModel& obj);
 
-    virtual ~SysModel(){};
+    virtual ~SysModel() {};
 
     /** Initializes the module, create messages */
-    virtual void SelfInit(){};
+    virtual void SelfInit() {};
 
     /** ??? */
-    virtual void IntegratedInit(){};
+    virtual void IntegratedInit() {};
 
     /** Reads incoming messages, performs module actions, writes output messages */
-    virtual void UpdateState(uint64_t CurrentSimNanos){};
+    virtual void UpdateState(uint64_t CurrentSimNanos) {};
 
     /** Called at simulation initialization, resets module to specified time */
-    virtual void Reset(uint64_t CurrentSimNanos){};
+    virtual void Reset(uint64_t CurrentSimNanos) {};
 
     std::string ModelTag = "";     //!< Basilisk module tag name
     uint64_t CallCounts = 0;       //!< Counts on the model being called
     uint32_t RNGSeed = 0x1badcad1; //!< Giving everyone a random seed for ease of MC
     int64_t moduleID;              //!< Module ID for this module  (handed out by module_id_generator)
 };
 
-
 #endif /* _SYS_MODEL_H_ */

src/architecture/_GeneralModuleFiles/sys_model_task.cpp

@@ -25,49 +25,50 @@
  @param FirstStartTime The amount of time in nanoseconds to hold a task dormant before starting.
         After this time the task is executed at integer amounts of InputPeriod again
  */
-SysModelTask::SysModelTask(uint64_t InputPeriod, uint64_t FirstStartTime) :
-    NextStartTime(FirstStartTime), TaskPeriod(InputPeriod), FirstTaskTime(FirstStartTime)
+SysModelTask::SysModelTask(uint64_t InputPeriod, uint64_t FirstStartTime)
+  : NextStartTime(FirstStartTime)
+  , TaskPeriod(InputPeriod)
+  , FirstTaskTime(FirstStartTime)
 {
     this->NextPickupTime = this->NextStartTime + this->TaskPeriod;
 }
 
 /*! This method self-initializes all of the models that have been added to the Task.
  */
-void SysModelTask::SelfInitTaskList() const
+void
+SysModelTask::SelfInitTaskList() const
 {
     //! - Loop over all models and do the self init for each
-    for(auto const& modelPair : this->TaskModels)
-    {
+    for (auto const& modelPair : this->TaskModels) {
         SysModel* NonIt = modelPair.ModelPtr;
         NonIt->SelfInit();
     }
 }
 
-
 /*! This method resets all of the models that have been added to the Task at the CurrentSimTime.
  See sys_model_task.h for related method ResetTask()
  @param CurrentSimTime The time to start at after reset
 */
-void SysModelTask::ResetTaskList(uint64_t CurrentSimTime)
+void
+SysModelTask::ResetTaskList(uint64_t CurrentSimTime)
 {
-	for (auto const& modelPair : this->TaskModels)
-	{
-		modelPair.ModelPtr->Reset(CurrentSimTime);
-	}
-	this->NextStartTime = CurrentSimTime;
+    for (auto const& modelPair : this->TaskModels) {
+        modelPair.ModelPtr->Reset(CurrentSimTime);
+    }
+    this->NextStartTime = CurrentSimTime;
     this->NextPickupTime = this->NextStartTime + this->TaskPeriod;
 }
 
 /*! This method executes all of the models on the Task during runtime.
  Then, it sets its NextStartTime appropriately.
  @param CurrentSimNanos The current simulation time in [ns]
  */
-void SysModelTask::ExecuteTaskList(uint64_t CurrentSimNanos)
+void
+SysModelTask::ExecuteTaskList(uint64_t CurrentSimNanos)
 {
     //! - Loop over all of the models in the simulation and call their UpdateState
-    for(auto ModelPair = this->TaskModels.begin(); (ModelPair != this->TaskModels.end() && this->taskActive);
-             ModelPair++)
-    {
+    for (auto ModelPair = this->TaskModels.begin(); (ModelPair != this->TaskModels.end() && this->taskActive);
+         ModelPair++) {
         SysModel* NonIt = (ModelPair->ModelPtr);
         NonIt->UpdateState(CurrentSimNanos);
         NonIt->CallCounts += 1;
@@ -81,21 +82,19 @@ void SysModelTask::ExecuteTaskList(uint64_t CurrentSimNanos)
  @param NewModel The new model that we are adding to the Task
  @param Priority The selected priority of the model being added (highest goes first)
  */
-void SysModelTask::AddNewObject(SysModel *NewModel, int32_t Priority)
+void
+SysModelTask::AddNewObject(SysModel* NewModel, int32_t Priority)
 {
     ModelPriorityPair LocalPair;
 
     //! - Set the local pair with the requested priority and mode
     LocalPair.CurrentModelPriority = Priority;
     LocalPair.ModelPtr = NewModel;
-//    SystemMessaging::GetInstance()->addModuleToProcess(NewModel->moduleID,
-//            parentProc);
+    //    SystemMessaging::GetInstance()->addModuleToProcess(NewModel->moduleID,
+    //            parentProc);
     //! - Loop through the ModelPair vector and if Priority is higher than next, insert
-    for(auto ModelPair = this->TaskModels.begin(); ModelPair != this->TaskModels.end();
-        ModelPair++)
-    {
-        if(Priority > ModelPair->CurrentModelPriority)
-        {
+    for (auto ModelPair = this->TaskModels.begin(); ModelPair != this->TaskModels.end(); ModelPair++) {
+        if (Priority > ModelPair->CurrentModelPriority) {
             this->TaskModels.insert(ModelPair, LocalPair);
             return;
         }
@@ -109,24 +108,21 @@ void SysModelTask::AddNewObject(SysModel *NewModel, int32_t Priority)
    was specified at task creation.
  @param newPeriod The period that the task should run at going forward
  */
-void SysModelTask::updatePeriod(uint64_t newPeriod)
+void
+SysModelTask::updatePeriod(uint64_t newPeriod)
 {
     //! - If the requested time is above the min time, set the next time based on the previous time plus the new period
-    if(this->NextStartTime > this->TaskPeriod)
-    {
-        uint64_t newStartTime = (this->NextStartTime/newPeriod)*newPeriod;
-        if(newStartTime <= (this->NextStartTime - this->TaskPeriod))
-        {
+    if (this->NextStartTime > this->TaskPeriod) {
+        uint64_t newStartTime = (this->NextStartTime / newPeriod) * newPeriod;
+        if (newStartTime <= (this->NextStartTime - this->TaskPeriod)) {
             newStartTime += newPeriod;
         }
         this->NextStartTime = newStartTime;
     }
     //! - Otherwise, we just should keep the original requested first call time for the task
-    else
-    {
+    else {
         this->NextStartTime = this->FirstTaskTime;
     }
     //! - Change the period of the task so that future calls will be based on the new period
     this->TaskPeriod = newPeriod;
-
 }

src/architecture/_GeneralModuleFiles/sys_model_task.h

@@ -26,39 +26,44 @@
 #include <vector>
 
 //! Structure used to pair a model and its requested priority
-typedef struct {
-    int32_t CurrentModelPriority;  //!< The current model priority. Higher goes first
-    SysModel *ModelPtr;  //!< The model associated with this priority
-}ModelPriorityPair;
+typedef struct
+{
+    int32_t CurrentModelPriority; //!< The current model priority. Higher goes first
+    SysModel* ModelPtr;           //!< The model associated with this priority
+} ModelPriorityPair;
 
 //! Class used to group a set of models into one "Task" of execution
 class SysModelTask
 {
 
-public:
-    SysModelTask()=default;
-    explicit SysModelTask(uint64_t InputPeriod, uint64_t FirstStartTime=0); //!< class method
-    ~SysModelTask()=default;
-    void AddNewObject(SysModel *NewModel, int32_t Priority = -1);
+  public:
+    SysModelTask() = default;
+    explicit SysModelTask(uint64_t InputPeriod, uint64_t FirstStartTime = 0); //!< class method
+    ~SysModelTask() = default;
+    void AddNewObject(SysModel* NewModel, int32_t Priority = -1);
     void SelfInitTaskList() const;
-    //void CrossInitTaskList();
+    // void CrossInitTaskList();
     void ExecuteTaskList(uint64_t CurrentSimTime);
-	void ResetTaskList(uint64_t CurrentSimTime);
-    void ResetTask() {this->NextStartTime = this->FirstTaskTime;} //!< Resets the task
-	void enableTask() {this->taskActive = true;} //!< Enables the task.  Great comment huh?
-	void disableTask() {this->taskActive = false;} //!< Disables the task.  I know.
+    void ResetTaskList(uint64_t CurrentSimTime);
+    void ResetTask() { this->NextStartTime = this->FirstTaskTime; } //!< Resets the task
+    void enableTask() { this->taskActive = true; }                  //!< Enables the task.  Great comment huh?
+    void disableTask() { this->taskActive = false; }                //!< Disables the task.  I know.
     void updatePeriod(uint64_t newPeriod);
-    void updateParentProc(std::string const& parent) {this->parentProc = parent;} //!< Allows the system to move task to a different process
+    void updateParentProc(std::string const& parent)
+    {
+        this->parentProc = parent;
+    } //!< Allows the system to move task to a different process
 
-    std::vector<ModelPriorityPair> TaskModels{};  //!< -- Array that has pointers to all task sysModels
-    std::string TaskName{};  //!< -- Identifier for Task
-    std::string parentProc; //!< -- Process that calls this task
-    uint64_t NextStartTime=0;  //!< [ns] Next time to start task
-    uint64_t NextPickupTime=0;  //!< [ns] Next time read Task outputs
-    uint64_t TaskPeriod=100;  //!< [ns] Cycle rate for Task
-    uint64_t FirstTaskTime=0;  //!< [ns] Time to start Task for first time.  After this time the normal periodic updates resume.
-	bool taskActive=true;  //!< -- Flag indicating whether the Task has been disabled
-  BSKLogger bskLogger;                      //!< -- BSK Logging
+    std::vector<ModelPriorityPair> TaskModels{}; //!< -- Array that has pointers to all task sysModels
+    std::string TaskName{};                      //!< -- Identifier for Task
+    std::string parentProc;                      //!< -- Process that calls this task
+    uint64_t NextStartTime = 0;                  //!< [ns] Next time to start task
+    uint64_t NextPickupTime = 0;                 //!< [ns] Next time read Task outputs
+    uint64_t TaskPeriod = 100;                   //!< [ns] Cycle rate for Task
+    uint64_t FirstTaskTime =
+      0; //!< [ns] Time to start Task for first time.  After this time the normal periodic updates resume.
+    bool taskActive = true; //!< -- Flag indicating whether the Task has been disabled
+    BSKLogger bskLogger;    //!< -- BSK Logging
 };
 
 #endif /* _SysModelTask_H_ */

src/architecture/alg_contain/alg_contain.cpp

@@ -23,47 +23,47 @@ AlgContain::AlgContain()
     AlgSelfInit = NULL;
     AlgUpdate = NULL;
     DataPtr = NULL;
-	AlgReset = NULL;
+    AlgReset = NULL;
     CallCounts = 0;
     return;
 }
 
-AlgContain::AlgContain(void *DataIn, void(*UpPtr) (void*, uint64_t, uint64_t),
+AlgContain::AlgContain(void* DataIn,
+                       void (*UpPtr)(void*, uint64_t, uint64_t),
                        void (*SelfPtr)(void*, uint64_t),
-	                   void (*ResetPtr) (void*, uint64_t, uint64_t))
+                       void (*ResetPtr)(void*, uint64_t, uint64_t))
 {
     DataPtr = DataIn;
     AlgSelfInit = SelfPtr;
     AlgUpdate = UpPtr;
-	AlgReset = ResetPtr;
+    AlgReset = ResetPtr;
 }
 
 AlgContain::~AlgContain()
 {
     return;
 }
 
-void AlgContain::SelfInit()
+void
+AlgContain::SelfInit()
 {
-    if(AlgSelfInit != NULL)
-    {
-        AlgSelfInit(DataPtr, (uint32_t) moduleID);
+    if (AlgSelfInit != NULL) {
+        AlgSelfInit(DataPtr, (uint32_t)moduleID);
     }
 }
 
-
-void AlgContain::UpdateState(uint64_t CurrentSimNanos)
+void
+AlgContain::UpdateState(uint64_t CurrentSimNanos)
 {
-    if(AlgUpdate != NULL)
-    {
-        AlgUpdate(DataPtr, CurrentSimNanos, (uint32_t) moduleID);
+    if (AlgUpdate != NULL) {
+        AlgUpdate(DataPtr, CurrentSimNanos, (uint32_t)moduleID);
     }
 }
 
-void AlgContain::Reset(uint64_t CurrentSimNanos)
+void
+AlgContain::Reset(uint64_t CurrentSimNanos)
 {
-	if (AlgReset != NULL)
-	{
-		AlgReset(DataPtr, CurrentSimNanos, (uint32_t) moduleID);
-	}
+    if (AlgReset != NULL) {
+        AlgReset(DataPtr, CurrentSimNanos, (uint32_t)moduleID);
+    }
 }