Rename state machine types

- sticking to naming convention for types, which is snake case

include/ls_std/core/types/StateMachineTypes.hpp

@@ -20,8 +20,8 @@ namespace ls
     {
       namespace type
       {
-        using StateConnectionId = ::std::string;
-        using StateId = ::std::string;
+        using state_connection_id = ::std::string;
+        using state_id = ::std::string;
       }
     }
   }

include/ls_std/logic/State.hpp

@@ -27,27 +27,27 @@ namespace ls
       {
         public:
 
-          explicit State(const ls::std::core::type::StateId &_id);
+          explicit State(const ls::std::core::type::state_id &_id);
           ~State() override = default;
 
           // additional functionality
 
-          bool addStateConnection(const ls::std::core::type::StateConnectionId &_connectionId, const ::std::shared_ptr<ls::std::logic::State> &_connectedState);
+          bool addStateConnection(const ls::std::core::type::state_connection_id &_connectionId, const ::std::shared_ptr<ls::std::logic::State> &_connectedState);
           bool addStateConnection(const ::std::shared_ptr<ls::std::logic::StateConnection> &_connection);
           void clearConnections();
-          ::std::unordered_map<ls::std::core::type::StateConnectionId, ::std::shared_ptr<ls::std::logic::StateConnection>> getConnectedStates();
-          ls::std::core::type::StateId getId();
-          bool hasConnection(const ls::std::core::type::StateConnectionId &_connectionId);
-          void setId(const ls::std::core::type::StateId &_id);
+          ::std::unordered_map<ls::std::core::type::state_connection_id, ::std::shared_ptr<ls::std::logic::StateConnection>> getConnectedStates();
+          ls::std::core::type::state_id getId();
+          bool hasConnection(const ls::std::core::type::state_connection_id &_connectionId);
+          void setId(const ls::std::core::type::state_id &_id);
 
         private:
 
-          ::std::unordered_map<ls::std::core::type::StateConnectionId, ::std::shared_ptr<ls::std::logic::StateConnection>> connectedStates{};
-          ls::std::core::type::StateId id{};
+          ::std::unordered_map<ls::std::core::type::state_connection_id, ::std::shared_ptr<ls::std::logic::StateConnection>> connectedStates{};
+          ls::std::core::type::state_id id{};
 
-          void _assignStateId(const ls::std::core::type::StateId &_id);
+          void _assignStateId(const ls::std::core::type::state_id &_id);
           void _clearConnections();
-          bool _hasConnection(const ls::std::core::type::StateConnectionId &_connectionId);
+          bool _hasConnection(const ls::std::core::type::state_connection_id &_connectionId);
       };
     }
   }

include/ls_std/logic/StateConnection.hpp

@@ -24,24 +24,24 @@ namespace ls
       {
         public:
 
-          explicit StateConnection(const ls::std::core::type::StateConnectionId &_connectionId, const ls::std::core::type::StateId &_stateId);
+          explicit StateConnection(const ls::std::core::type::state_connection_id &_connectionId, const ls::std::core::type::state_id &_stateId);
           ~StateConnection() override = default;
 
-          ls::std::core::type::StateConnectionId getConnectionId();
-          ls::std::core::type::StateId getStateId();
+          ls::std::core::type::state_connection_id getConnectionId();
+          ls::std::core::type::state_id getStateId();
           bool isPassable() const;
-          void setConnectionId(const ls::std::core::type::StateConnectionId &_connectionId);
-          void setStateId(const ls::std::core::type::StateId &_stateId);
+          void setConnectionId(const ls::std::core::type::state_connection_id &_connectionId);
+          void setStateId(const ls::std::core::type::state_id &_stateId);
           void updatePassCondition(bool _condition);
 
         private:
 
           bool condition{};
-          ls::std::core::type::StateConnectionId connectionId{};
-          ls::std::core::type::StateId stateId{};
+          ls::std::core::type::state_connection_id connectionId{};
+          ls::std::core::type::state_id stateId{};
 
-          void _assignConnectionId(const ls::std::core::type::StateConnectionId &_connectionId);
-          void _assignStateId(const ls::std::core::type::StateId &_stateId);
+          void _assignConnectionId(const ls::std::core::type::state_connection_id &_connectionId);
+          void _assignStateId(const ls::std::core::type::state_id &_stateId);
       };
     }
   }

include/ls_std/logic/StateMachine.hpp

@@ -33,27 +33,27 @@ namespace ls
 
           bool addState(const ::std::shared_ptr<ls::std::logic::State> &_state);
           ::std::shared_ptr<ls::std::logic::State> getCurrentState();
-          ::std::vector<ls::std::core::type::StateId> getMemory();
+          ::std::vector<ls::std::core::type::state_id> getMemory();
           ::std::string getName();
-          ::std::unordered_map<ls::std::core::type::StateId, ::std::shared_ptr<ls::std::logic::State>> getStates();
-          bool hasState(const ls::std::core::type::StateId &_id);
+          ::std::unordered_map<ls::std::core::type::state_id, ::std::shared_ptr<ls::std::logic::State>> getStates();
+          bool hasState(const ls::std::core::type::state_id &_id);
           bool proceed();
-          void setMemory(const ::std::vector<ls::std::core::type::StateId> &_memory);
+          void setMemory(const ::std::vector<ls::std::core::type::state_id> &_memory);
           void setName(const ::std::string &_name);
-          bool setStartState(const ls::std::core::type::StateId &_id);
+          bool setStartState(const ls::std::core::type::state_id &_id);
 
         private:
 
           ::std::shared_ptr<ls::std::logic::State> currentState{};
-          ::std::vector<ls::std::core::type::StateId> memory{};
+          ::std::vector<ls::std::core::type::state_id> memory{};
           ::std::string name{};
-          ::std::unordered_map<ls::std::core::type::StateId, ::std::shared_ptr<ls::std::logic::State>> states{};
+          ::std::unordered_map<ls::std::core::type::state_id, ::std::shared_ptr<ls::std::logic::State>> states{};
 
-          void _assignMemory(const ::std::vector<ls::std::core::type::StateId> &_memory);
+          void _assignMemory(const ::std::vector<ls::std::core::type::state_id> &_memory);
           void _assignName(const ::std::string &_name);
-          ::std::vector<ls::std::core::type::StateId> _getNextValidStates();
-          void _remember(const ls::std::core::type::StateId &_id);
-          bool _hasState(const ls::std::core::type::StateId &_id);
+          ::std::vector<ls::std::core::type::state_id> _getNextValidStates();
+          void _remember(const ls::std::core::type::state_id &_id);
+          bool _hasState(const ls::std::core::type::state_id &_id);
       };
     }
   }

source/ls_std/logic/State.cpp

@@ -10,12 +10,12 @@
 #include <ls_std/logic/State.hpp>
 #include <ls_std/core/exception/IllegalArgumentException.hpp>
 
-ls::std::logic::State::State(const ls::std::core::type::StateId& _id) : ls::std::core::Class("State")
+ls::std::logic::State::State(const ls::std::core::type::state_id& _id) : ls::std::core::Class("State")
 {
   this->_assignStateId(_id);
 }
 
-bool ls::std::logic::State::addStateConnection(const ls::std::core::type::StateConnectionId &_connectionId, const ::std::shared_ptr<ls::std::logic::State> &_connectedState)
+bool ls::std::logic::State::addStateConnection(const ls::std::core::type::state_connection_id &_connectionId, const ::std::shared_ptr<ls::std::logic::State> &_connectedState)
 {
   bool added{};
   ::std::shared_ptr<ls::std::logic::StateConnection> connection{};
@@ -57,27 +57,27 @@ void ls::std::logic::State::clearConnections()
   this->_clearConnections();
 }
 
-std::unordered_map<ls::std::core::type::StateConnectionId, std::shared_ptr<ls::std::logic::StateConnection>> ls::std::logic::State::getConnectedStates()
+std::unordered_map<ls::std::core::type::state_connection_id, std::shared_ptr<ls::std::logic::StateConnection>> ls::std::logic::State::getConnectedStates()
 {
   return this->connectedStates;
 }
 
-ls::std::core::type::StateId ls::std::logic::State::getId()
+ls::std::core::type::state_id ls::std::logic::State::getId()
 {
   return this->id;
 }
 
-bool ls::std::logic::State::hasConnection(const ls::std::core::type::StateConnectionId &_connectionId)
+bool ls::std::logic::State::hasConnection(const ls::std::core::type::state_connection_id &_connectionId)
 {
   return this->_hasConnection(_connectionId);
 }
 
-void ls::std::logic::State::setId(const ls::std::core::type::StateId& _id)
+void ls::std::logic::State::setId(const ls::std::core::type::state_id& _id)
 {
   this->_assignStateId(_id);
 }
 
-void ls::std::logic::State::_assignStateId(const ls::std::core::type::StateId &_id)
+void ls::std::logic::State::_assignStateId(const ls::std::core::type::state_id &_id)
 {
   if (_id.empty())
   {
@@ -92,7 +92,7 @@ void ls::std::logic::State::_clearConnections()
   this->connectedStates.clear();
 }
 
-bool ls::std::logic::State::_hasConnection(const ls::std::core::type::StateConnectionId &_connectionId)
+bool ls::std::logic::State::_hasConnection(const ls::std::core::type::state_connection_id &_connectionId)
 {
   return this->connectedStates.find(_connectionId) != this->connectedStates.end();
 }

source/ls_std/logic/StateConnection.cpp

@@ -10,18 +10,18 @@
 #include <ls_std/logic/StateConnection.hpp>
 #include <ls_std/core/exception/IllegalArgumentException.hpp>
 
-ls::std::logic::StateConnection::StateConnection(const ls::std::core::type::StateConnectionId& _connectionId, const ls::std::core::type::StateId& _stateId) : ls::std::core::Class("StateConnection")
+ls::std::logic::StateConnection::StateConnection(const ls::std::core::type::state_connection_id& _connectionId, const ls::std::core::type::state_id& _stateId) : ls::std::core::Class("StateConnection")
 {
   this->_assignConnectionId(_connectionId);
   this->_assignStateId(_stateId);
 }
 
-ls::std::core::type::StateConnectionId ls::std::logic::StateConnection::getConnectionId()
+ls::std::core::type::state_connection_id ls::std::logic::StateConnection::getConnectionId()
 {
   return this->connectionId;
 }
 
-ls::std::core::type::StateId ls::std::logic::StateConnection::getStateId()
+ls::std::core::type::state_id ls::std::logic::StateConnection::getStateId()
 {
   return this->stateId;
 }
@@ -31,12 +31,12 @@ bool ls::std::logic::StateConnection::isPassable() const
   return this->condition;
 }
 
-void ls::std::logic::StateConnection::setConnectionId(const ls::std::core::type::StateConnectionId& _connectionId)
+void ls::std::logic::StateConnection::setConnectionId(const ls::std::core::type::state_connection_id& _connectionId)
 {
   this->_assignConnectionId(_connectionId);
 }
 
-void ls::std::logic::StateConnection::setStateId(const ls::std::core::type::StateId& _stateId)
+void ls::std::logic::StateConnection::setStateId(const ls::std::core::type::state_id& _stateId)
 {
   this->_assignStateId(_stateId);
 }
@@ -46,7 +46,7 @@ void ls::std::logic::StateConnection::updatePassCondition(bool _condition)
   this->condition = _condition;
 }
 
-void ls::std::logic::StateConnection::_assignConnectionId(const ls::std::core::type::StateConnectionId &_connectionId)
+void ls::std::logic::StateConnection::_assignConnectionId(const ls::std::core::type::state_connection_id &_connectionId)
 {
   if (_connectionId.empty())
   {
@@ -56,7 +56,7 @@ void ls::std::logic::StateConnection::_assignConnectionId(const ls::std::core::t
   this->connectionId = _connectionId;
 }
 
-void ls::std::logic::StateConnection::_assignStateId(const ls::std::core::type::StateId &_stateId)
+void ls::std::logic::StateConnection::_assignStateId(const ls::std::core::type::state_id &_stateId)
 {
   if (_stateId.empty())
   {

source/ls_std/logic/StateMachine.cpp

@@ -39,7 +39,7 @@ std::shared_ptr<ls::std::logic::State> ls::std::logic::StateMachine::getCurrentS
   return this->currentState;
 }
 
-std::vector<ls::std::core::type::StateId> ls::std::logic::StateMachine::getMemory()
+std::vector<ls::std::core::type::state_id> ls::std::logic::StateMachine::getMemory()
 {
   return this->memory;
 }
@@ -49,19 +49,19 @@ std::string ls::std::logic::StateMachine::getName()
   return this->name;
 }
 
-std::unordered_map<ls::std::core::type::StateId, std::shared_ptr<ls::std::logic::State>> ls::std::logic::StateMachine::getStates()
+std::unordered_map<ls::std::core::type::state_id, std::shared_ptr<ls::std::logic::State>> ls::std::logic::StateMachine::getStates()
 {
   return this->states;
 }
 
-bool ls::std::logic::StateMachine::hasState(const ls::std::core::type::StateId &_id)
+bool ls::std::logic::StateMachine::hasState(const ls::std::core::type::state_id &_id)
 {
   return this->_hasState(_id);
 }
 
 bool ls::std::logic::StateMachine::proceed()
 {
-  ::std::vector<ls::std::core::type::StateId> nextValidStates = this->_getNextValidStates();
+  ::std::vector<ls::std::core::type::state_id> nextValidStates = this->_getNextValidStates();
   bool onlyOneWayToGo = nextValidStates.size() == 1;
 
   if (onlyOneWayToGo)
@@ -73,7 +73,7 @@ bool ls::std::logic::StateMachine::proceed()
   return onlyOneWayToGo;
 }
 
-void ls::std::logic::StateMachine::setMemory(const ::std::vector<ls::std::core::type::StateId>& _memory)
+void ls::std::logic::StateMachine::setMemory(const ::std::vector<ls::std::core::type::state_id>& _memory)
 {
   this->_assignMemory(_memory);
 }
@@ -83,7 +83,7 @@ void ls::std::logic::StateMachine::setName(const ::std::string& _name)
   this->_assignName(_name);
 }
 
-bool ls::std::logic::StateMachine::setStartState(const ls::std::core::type::StateId &_id)
+bool ls::std::logic::StateMachine::setStartState(const ls::std::core::type::state_id &_id)
 {
   bool startStateSet{};
 
@@ -104,7 +104,7 @@ bool ls::std::logic::StateMachine::setStartState(const ls::std::core::type::Stat
   return startStateSet;
 }
 
-void ls::std::logic::StateMachine::_assignMemory(const ::std::vector<ls::std::core::type::StateId> &_memory)
+void ls::std::logic::StateMachine::_assignMemory(const ::std::vector<ls::std::core::type::state_id> &_memory)
 {
   if (_memory.empty())
   {
@@ -124,9 +124,9 @@ void ls::std::logic::StateMachine::_assignName(const ::std::string &_name)
   this->name = _name;
 }
 
-std::vector<ls::std::core::type::StateId> ls::std::logic::StateMachine::_getNextValidStates()
+std::vector<ls::std::core::type::state_id> ls::std::logic::StateMachine::_getNextValidStates()
 {
-  ::std::vector<ls::std::core::type::StateId> validStates{};
+  ::std::vector<ls::std::core::type::state_id> validStates{};
 
   for (const auto &state : this->currentState->getConnectedStates())
   {
@@ -139,12 +139,12 @@ std::vector<ls::std::core::type::StateId> ls::std::logic::StateMachine::_getNext
   return validStates;
 }
 
-void ls::std::logic::StateMachine::_remember(const ls::std::core::type::StateId &_id)
+void ls::std::logic::StateMachine::_remember(const ls::std::core::type::state_id &_id)
 {
   this->memory.push_back(_id);
 }
 
-bool ls::std::logic::StateMachine::_hasState(const ls::std::core::type::StateId &_id)
+bool ls::std::logic::StateMachine::_hasState(const ls::std::core::type::state_id &_id)
 {
   return this->states.find(_id) != this->states.end();
 }

test/cases/logic/StateMachineTest.cpp

@@ -172,7 +172,7 @@ namespace
   TEST_F(StateMachineTest, setMemory_no_memory)
   {
     ls::std::logic::StateMachine stateMachine{"test_machine"};
-    std::vector<ls::std::core::type::StateId> memory{};
+    std::vector<ls::std::core::type::state_id> memory{};
 
     EXPECT_THROW({
                    try