style: Applied ROS C++ Style Guide

Author: Format Bot

include/am_super/state_mediator.h

@@ -7,33 +7,31 @@
 
 namespace am
 {
-
 /**
- * Provides all logic about system State allowing the State objects 
- * to be simply data objects.  Allows the ROS node to hold the state of the 
- * system, but delegates all logic to here improving readability, encapsulation 
+ * Provides all logic about system State allowing the State objects
+ * to be simply data objects.  Allows the ROS node to hold the state of the
+ * system, but delegates all logic to here improving readability, encapsulation
  * and ability to test.
- * 
+ *
  * This class is stateless, but non-static allowing extension to change behavior
- * if different deployments warrant different behavior. 
+ * if different deployments warrant different behavior.
  */
 class StateMediator
 {
-
 public:
   StateMediator();
 
-  /** An indicator that the string is not valid. 
+  /** An indicator that the string is not valid.
    * Instead of throwing an exception which causes difficult to debug seg faults
-   * or returning an empty string creating a mystery of what why something is missing. 
+   * or returning an empty string creating a mystery of what why something is missing.
    **/
   static constexpr std::string_view INVALID_STRING = "INVALID";
 
   /** See https://automodality.atlassian.net/wiki/spaces/AMROS/pages/929234949/AMROS+System+States
    * @return true if the new state is acceptable to follow the current.
    */
   bool allowsTransition(SuperState from, SuperState to);
-  
+
   /**
    * @return a vector of all states in order of declaration, excluding LastState which is used for enum iteration
    */

src/am_super/am_super.cpp

@@ -764,28 +764,29 @@ class AMSuper
   {
     ROS_INFO_STREAM("request change system state from: " << stateToString(system_state_)
                                                          << " to: " << stateToString(state));
-    bool legal = state_mediator_.allowsTransition(system_state_,state);
+    bool legal = state_mediator_.allowsTransition(system_state_, state);
 
     if (!legal)
     {
-      ROS_ERROR_STREAM("illegal state transition from " 
-        << stateToString(system_state_) << " to " << stateToString(state));
+      ROS_ERROR_STREAM("illegal state transition from " << stateToString(system_state_) << " to "
+                                                        << stateToString(state));
     }
     else
     {
-      //send lifecycle updates for selected state transitions
-      switch(state){
+      // send lifecycle updates for selected state transitions
+      switch (state)
+      {
         case SuperState::READY:
-            ROS_INFO_STREAM("sending CONFIGURE to all nodes");
-            sendLifeCycleCommand(AMLifeCycle::BROADCAST_NODE_NAME, LifeCycleCommand::CONFIGURE);
+          ROS_INFO_STREAM("sending CONFIGURE to all nodes");
+          sendLifeCycleCommand(AMLifeCycle::BROADCAST_NODE_NAME, LifeCycleCommand::CONFIGURE);
           break;
         case SuperState::ARMING:
-            ROS_INFO_STREAM("sending ACTIVATE to all nodes");
-            sendLifeCycleCommand(AMLifeCycle::BROADCAST_NODE_NAME, LifeCycleCommand::ACTIVATE);
+          ROS_INFO_STREAM("sending ACTIVATE to all nodes");
+          sendLifeCycleCommand(AMLifeCycle::BROADCAST_NODE_NAME, LifeCycleCommand::ACTIVATE);
           break;
       }
-       
-      //persist given state as the new current state
+
+      // persist given state as the new current state
       system_state_ = state;
 
       reportSystemState();

src/am_super/state_mediator.cpp

@@ -2,46 +2,47 @@
 
 namespace am
 {
-
-const std::map<SuperState, std::vector<SuperState>> transitions_ =
-{
-    { SuperState::OFF, {SuperState::BOOTING} },
-    { SuperState::BOOTING, {SuperState::READY} },
-    { SuperState::READY, {SuperState::ARMING} },
-    { SuperState::ARMING, {SuperState::ARMED} },
-    { SuperState::ARMED, {SuperState::AUTO, SuperState::ABORT} },
-    { SuperState::AUTO, {SuperState::READY,SuperState::SEMI_AUTO,SuperState::HOLD,SuperState::ABORT,SuperState::MANUAL} },
-    { SuperState::SEMI_AUTO, {SuperState::AUTO,SuperState::HOLD,SuperState::ABORT,SuperState::MANUAL} },
-    { SuperState::HOLD, {SuperState::ABORT,SuperState::MANUAL} },
-    { SuperState::ABORT, {SuperState::READY,SuperState::MANUAL} },
-    { SuperState::MANUAL, {SuperState::READY} },
-    { SuperState::SHUTDOWN, {SuperState::OFF} },
+const std::map<SuperState, std::vector<SuperState>> transitions_ = {
+  { SuperState::OFF, { SuperState::BOOTING } },
+  { SuperState::BOOTING, { SuperState::READY } },
+  { SuperState::READY, { SuperState::ARMING } },
+  { SuperState::ARMING, { SuperState::ARMED } },
+  { SuperState::ARMED, { SuperState::AUTO, SuperState::ABORT } },
+  { SuperState::AUTO,
+    { SuperState::READY, SuperState::SEMI_AUTO, SuperState::HOLD, SuperState::ABORT, SuperState::MANUAL } },
+  { SuperState::SEMI_AUTO, { SuperState::AUTO, SuperState::HOLD, SuperState::ABORT, SuperState::MANUAL } },
+  { SuperState::HOLD, { SuperState::ABORT, SuperState::MANUAL } },
+  { SuperState::ABORT, { SuperState::READY, SuperState::MANUAL } },
+  { SuperState::MANUAL, { SuperState::READY } },
+  { SuperState::SHUTDOWN, { SuperState::OFF } },
 };
 
-const std::map<SuperState, std::string_view> state_strings_ =
-{
-    { SuperState::OFF, "OFF" },
-    { SuperState::BOOTING, "BOOTING" },
-    { SuperState::READY, "READY" },
-    { SuperState::ARMING, "ARMING" },
-    { SuperState::ARMED,  "ARMED" },
-    { SuperState::AUTO, "AUTO" },
-    { SuperState::SEMI_AUTO, "SEMI_AUTO" },
-    { SuperState::HOLD, "HOLD" },
-    { SuperState::ABORT, "ABORT" },
-    { SuperState::MANUAL,  "MANUAL" },
-    { SuperState::SHUTDOWN,  "SHUTDOWN" },
+const std::map<SuperState, std::string_view> state_strings_ = {
+  { SuperState::OFF, "OFF" },
+  { SuperState::BOOTING, "BOOTING" },
+  { SuperState::READY, "READY" },
+  { SuperState::ARMING, "ARMING" },
+  { SuperState::ARMED, "ARMED" },
+  { SuperState::AUTO, "AUTO" },
+  { SuperState::SEMI_AUTO, "SEMI_AUTO" },
+  { SuperState::HOLD, "HOLD" },
+  { SuperState::ABORT, "ABORT" },
+  { SuperState::MANUAL, "MANUAL" },
+  { SuperState::SHUTDOWN, "SHUTDOWN" },
 };
 
-StateMediator::StateMediator(){
+StateMediator::StateMediator()
+{
 }
 
 bool StateMediator::allowsTransition(SuperState from, SuperState to)
 {
   bool legal = false;
-  if(transitions_.count(from) > 0){
+  if (transitions_.count(from) > 0)
+  {
     std::vector<SuperState> allowed = transitions_.at(from);
-    if(std::find(allowed.begin(),allowed.end(),to) != allowed.end()){
+    if (std::find(allowed.begin(), allowed.end(), to) != allowed.end())
+    {
       legal = true;
     }
   }
@@ -51,20 +52,22 @@ bool StateMediator::allowsTransition(SuperState from, SuperState to)
 std::vector<SuperState> StateMediator::allSuperStates()
 {
   std::vector<SuperState> all;
-  for ( int enumIndex = (int) SuperState::OFF; enumIndex <= (int) SuperState::LAST_STATE; enumIndex++ )
+  for (int enumIndex = (int)SuperState::OFF; enumIndex <= (int)SuperState::LAST_STATE; enumIndex++)
   {
     SuperState state = static_cast<SuperState>(enumIndex);
     all.push_back(state);
   }
   return all;
 }
 
-
 std::string_view StateMediator::stateToString(SuperState state)
 {
-  if(state_strings_.count(state) > 0){
+  if (state_strings_.count(state) > 0)
+  {
     return state_strings_.at(state);
-  }else{
+  }
+  else
+  {
     return INVALID_STRING;
   }
 }