Add NodeIndexType

Author: ProgramMax

Code/max/Containers/StateMachine/Node.hpp

@@ -16,25 +16,26 @@ namespace max {
 namespace Containers {
 namespace StateMachine {
 
-	template<typename... TransitionTypes>
+	template<typename NodeIndexType, typename... TransitionTypes>
 	class Node {
 	public:
 
-		constexpr explicit Node(std::tuple<TransitionTypes...> outbound_transitions) noexcept
-			: outbound_transitions_(std::move(outbound_transitions))
+		constexpr explicit Node(NodeIndexType this_node, std::tuple<TransitionTypes...> outbound_transitions) noexcept
+			: this_node_(std::move(this_node))
+			, outbound_transitions_(std::move(outbound_transitions))
 		{}
 
-		template<typename T>
-		constexpr std::optional<size_t> AttemptTransition(const T& input) noexcept {
+		template<typename NodeIndexType, typename T>
+		constexpr std::optional<NodeIndexType> AttemptTransition(const T& input) noexcept {
 			auto transition_happened = false;
-			auto new_node_index = std::optional<size_t>{std::nullopt};
+			auto new_node_index = std::optional<NodeIndexType>{std::nullopt};
 
 			auto attempt_transition = [&transition_happened, &new_node_index, &input](auto&& arg) {
 				// TODO: I added .value_ to RangeMatcher because I couldn't get this line to work
 				//if constexpr (std::is_same_v<T, decltype(arg.matcher_)::parameter_type>) {
 				if constexpr (std::is_same_v<T, decltype(arg.matcher_.value_)>) {
 					if (!transition_happened) {
-						auto possible_new_node_index = arg.AttemptTransition(input);
+						auto possible_new_node_index = arg.AttemptTransition<NodeIndexType>(input);
 						if (possible_new_node_index) {
 							transition_happened = true;
 							new_node_index = std::move(possible_new_node_index);
@@ -50,13 +51,14 @@ namespace StateMachine {
 			return new_node_index;
 		}
 
+		NodeIndexType this_node_;
 		std::tuple<TransitionTypes...> outbound_transitions_;
 
 	};
 
-	template<typename... TransitionTypes>
-	constexpr Node<TransitionTypes...> MakeNode(TransitionTypes... outbound_transitions) noexcept {
-		return Node{std::make_tuple(std::move(outbound_transitions) ...)};
+	template<typename NodeIndexType, typename... TransitionTypes>
+	constexpr Node<NodeIndexType, TransitionTypes...> MakeNode(NodeIndexType this_node, TransitionTypes... outbound_transitions) noexcept {
+		return Node{std::move(this_node), std::make_tuple(std::move(outbound_transitions) ...)};
 	}
 
 } // namespace StateMachine

Code/max/Containers/StateMachine/StateMachine.hpp

@@ -12,22 +12,22 @@ namespace max {
 namespace Containers {
 namespace StateMachine {
 
-	template<typename... NodeTypes>
+	template<typename NodeIndexType, typename... NodeTypes>
 	class StateMachine {
 	public:
 
-		constexpr explicit StateMachine(std::tuple<NodeTypes...> nodes) noexcept
+		constexpr explicit StateMachine(NodeIndexType starting_node, std::tuple<NodeTypes...> nodes) noexcept
 			: nodes_(std::move(nodes))
-			, current_node_index_(0)
+			, current_node_index_(std::move(starting_node))
 		{}
 
 		template<typename T>
 		constexpr void AttemptTransition(T input) noexcept {
 			auto transition_happened = false;
 			auto i = size_t{0};
 			auto attempt_transition = [this, &transition_happened, &i, &input](auto&& arg) {
-				if (!transition_happened && current_node_index_ == i++) {
-					auto possible_new_node_index = arg.AttemptTransition(input);
+				if (!transition_happened && current_node_index_ == arg.this_node_) {
+					auto possible_new_node_index = arg.AttemptTransition<NodeIndexType>(input);
 					if (possible_new_node_index) {
 						transition_happened = true;
 						current_node_index_ = std::move(possible_new_node_index.value());
@@ -41,7 +41,7 @@ namespace StateMachine {
 		}
 
 		std::tuple<NodeTypes...> nodes_;
-		size_t current_node_index_;
+		NodeIndexType current_node_index_;
 
 	};
 

Code/max/Containers/StateMachine/Transition.hpp

@@ -21,8 +21,8 @@ namespace StateMachine {
 			, callback_(std::move(callback))
 		{}
 
-		template<typename T>
-		constexpr std::optional<size_t> AttemptTransition(const T& input) noexcept {
+		template<typename NodeIndexType, typename T>
+		constexpr std::optional<NodeIndexType> AttemptTransition(const T& input) noexcept {
 			if (matcher_.DoesMatch(input)) {
 				return callback_(std::move(input));
 			}