Added Nested State ( missing tests )

ZigRazor · ZigRazor · commit 6a6fe887f82a · 2025-07-01T13:56:09.000+02:00
diff --git a/.vscode/settings.json b/.vscode/settings.json
@@ -47,6 +47,27 @@
         "streambuf": "cpp",
         "text_encoding": "cpp",
         "typeinfo": "cpp",
-        "variant": "cpp"
+        "variant": "cpp",
+        "any": "cpp",
+        "chrono": "cpp",
+        "condition_variable": "cpp",
+        "csignal": "cpp",
+        "cstring": "cpp",
+        "forward_list": "cpp",
+        "list": "cpp",
+        "map": "cpp",
+        "set": "cpp",
+        "unordered_set": "cpp",
+        "ratio": "cpp",
+        "fstream": "cpp",
+        "iomanip": "cpp",
+        "iostream": "cpp",
+        "istream": "cpp",
+        "mutex": "cpp",
+        "semaphore": "cpp",
+        "sstream": "cpp",
+        "stop_token": "cpp",
+        "thread": "cpp",
+        "cinttypes": "cpp"
     }
 }
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -10,6 +10,10 @@ target_include_directories(CXXStateTree INTERFACE include)
 add_executable(basic examples/basic.cpp)
 target_link_libraries(basic PRIVATE CXXStateTree)
 
+
+add_executable(nested examples/nested.cpp)
+target_link_libraries(nested PRIVATE CXXStateTree)
+
 # GoogleTest setup
 include(FetchContent)
 FetchContent_Declare(
diff --git a/examples/basic.cpp b/examples/basic.cpp
@@ -25,15 +25,15 @@ int main()
                                      { std::cout << "Transition: Paused -> Running" << std::endl; }); })
                        .build();
 
-    std::cout << "Initial state: " << machine.current_state() << std::endl;
+    std::cout << "Initial state: " << machine.current_state().name() << std::endl;
     machine.send("Start");
-    std::cout << "Current state: " << machine.current_state() << std::endl;
+    std::cout << "Current state: " << machine.current_state().name() << std::endl;
     machine.send("Pause");
-    std::cout << "Current state: " << machine.current_state() << std::endl;
+    std::cout << "Current state: " << machine.current_state().name() << std::endl;
     machine.send("Resume");
-    std::cout << "Current state: " << machine.current_state() << std::endl;
+    std::cout << "Current state: " << machine.current_state().name() << std::endl;
     machine.send("Stop");
-    std::cout << "Current state: " << machine.current_state() << std::endl;
+    std::cout << "Current state: " << machine.current_state().name() << std::endl;
 
     return 0;
 }
diff --git a/examples/nested.cpp b/examples/nested.cpp
@@ -0,0 +1,49 @@
+// File: examples/basic.cpp
+#include <iostream>
+#include "CXXStateTree/Builder.hpp"
+
+using namespace CXXStateTree;
+
+int main()
+{
+    auto machine = Builder()
+                       .initial("Main")
+                       .state("Main", [](State &s)
+                              { s.initial_substate("Idle")
+                                    .substate("Idle", [](State &s)
+                                              { s.on("Start", "Running", nullptr, []()
+                                                     { std::cout << "Transition: Idle -> Running" << std::endl; }); })
+
+                                    .substate("Running", [](State &s)
+                                              { s.on("Stop", "Idle", nullptr, []()
+                                                     { std::cout << "Transition: Running -> idle" << std::endl; }); })
+
+                                    .on("Switch", "Alternate", nullptr, []()
+                                        { std::cout << "Transition: Main -> Alternate" << std::endl; }); })
+                       .state("Alternate", [](State &s)
+                              { s.initial_substate("Idle")
+                                    .substate("Idle", [](State &s)
+                                              { s.on("Start", "Running", nullptr, []()
+                                                     { std::cout << "Transition: Idle -> Running" << std::endl; }); })
+
+                                    .substate("Running", [](State &s)
+                                              { s.on("Stop", "Idle", nullptr, []()
+                                                     { std::cout << "Transition: Running -> idle" << std::endl; }); })
+                                    .on("Switch", "Main", nullptr, []()
+                                        { std::cout << "Transition: Alternate -> Main" << std::endl; }); })
+                       .build();
+
+    std::cout << "Initial state: " << machine.current_state().fullName() << std::endl;
+    machine.send("Start");
+    std::cout << "Current state: " << machine.current_state().fullName() << std::endl;
+    machine.send("Stop");
+    std::cout << "Current state: " << machine.current_state().fullName() << std::endl;
+    machine.send("Switch");
+    std::cout << "Current state: " << machine.current_state().fullName() << std::endl;
+    machine.send("Start");
+    std::cout << "Current state: " << machine.current_state().fullName() << std::endl;
+    machine.send("Stop");
+    std::cout << "Current state: " << machine.current_state().fullName() << std::endl;
+
+    return 0;
+}
diff --git a/include/CXXStateTree/Builder.hpp b/include/CXXStateTree/Builder.hpp
@@ -1,5 +1,6 @@
 #pragma once
 
+#include <list>
 #include "StateTree.hpp"
 
 namespace CXXStateTree
@@ -16,23 +17,25 @@ namespace CXXStateTree
 
         Builder &state(const std::string &name, std::function<void(State &)> config)
         {
-            State s(name);
-            config(s);
-            states_.insert({name, std::move(s)});
+            states_.emplace_back(name);
+            config(states_.back());
             return *this;
         }
 
         StateTree build()
         {
-            if (initial_state_.empty())
+            StateTree tree;
+            tree.states_ = std::move(states_);
+            tree.current_ = tree.find_state(initial_state_);
+            if (tree.current_ && tree.current_->initial_substate())
             {
-                throw std::runtime_error("Initial state not set");
+                tree.current_ = tree.current_->find_substate(*tree.current_->initial_substate());
             }
-            return StateTree(states_, initial_state_);
+            return tree;
         }
 
     private:
-        std::unordered_map<std::string, State> states_;
+        std::list<State> states_;
         std::string initial_state_;
     };
 } // namespace CXXStateTree
diff --git a/include/CXXStateTree/State.hpp b/include/CXXStateTree/State.hpp
@@ -1,5 +1,6 @@
 #pragma once
 
+#include <list>
 #include "Transition.hpp"
 
 namespace CXXStateTree
@@ -8,26 +9,66 @@ namespace CXXStateTree
     class State
     {
     public:
-        explicit State(std::string name) : name_(std::move(name)) {}
+        explicit State(std::string name, State *parent = nullptr) : name_(std::move(name)), parent_(parent) {}
 
-        void on(const std::string &event, const std::string &target,
-                Guard guard = nullptr, Action action = nullptr)
+        State &on(const std::string &event, const std::string &target,
+                  Guard guard = nullptr, Action action = nullptr)
         {
-            transitions_[event] = Transition{target, guard, action};
+            transitions_[event] = {std::move(target), guard, std::move(action)};
+            return *this;
         }
 
-        std::optional<Transition> get_transition(const std::string &event) const
+        State &initial_substate(const std::string &name)
         {
-            auto it = transitions_.find(event);
-            if (it != transitions_.end())
-                return it->second;
-            return std::nullopt;
+            initial_substate_ = name;
+            return *this;
+        }
+
+        State &substate(const std::string &name, std::function<void(State &)> config)
+        {
+            substates_.emplace_back(name, this);
+            State &new_substate = substates_.back();
+            config(new_substate);
+            return *this;
         }
 
         const std::string &name() const { return name_; }
+        std::string fullName() const
+        {
+            if (parent_ != nullptr)
+            {
+                std::string result = parent_->fullName() + "." + name_;
+                return result;
+            }
+            else
+            {
+                return name_;
+            }
+        }
+        const std::list<State> &substates() const { return substates_; }
+        const std::unordered_map<std::string, Transition> &transitions() const { return transitions_; }
+        const std::optional<std::string> &initial_substate() const { return initial_substate_; }
+        const State *parent() const { return parent_; }
+
+        const State *find_substate(const std::string &name) const
+        {
+            for (const auto &s : substates_)
+            {
+                if (s.name() == name)
+                    return &s;
+            }
+            if (parent_ != nullptr)
+            {
+                return parent_->find_substate(name);
+            }
+            return nullptr;
+        }
 
     private:
         std::string name_;
+        State *parent_ = nullptr;
+        std::list<State> substates_;
         std::unordered_map<std::string, Transition> transitions_;
+        std::optional<std::string> initial_substate_;
     };
 } // namespace CXXStateTree
diff --git a/include/CXXStateTree/StateTree.hpp b/include/CXXStateTree/StateTree.hpp
@@ -24,29 +24,102 @@ namespace CXXStateTree
 
         void send(const std::string &event)
         {
-            const auto &current = states_.at(current_state_);
-            auto trans = current.get_transition(event);
-            if (trans && (!trans->guard.has_value() || (trans->guard.has_value() && !trans->guard.value()) || (*trans->guard)()))
+            if (!current_)
+                return;
+            const auto &transitions = current_->transitions();
+            auto it = transitions.find(event);
+            if (it != transitions.end())
             {
-                if (trans->action.has_value() && trans->action.value() != nullptr)
+                const auto &trans = it->second;
+                if (trans.guard && !trans.guard())
+                    return;
+                if (trans.action)
+                    trans.action();
+                current_ = find_state(trans.target);
+                if (current_ && current_->initial_substate())
                 {
-                    (*trans->action)();
+                    current_ = current_->find_substate(*current_->initial_substate());
                 }
-                current_state_ = trans->target;
+            }
+            // try to send the event to parent states
+            else if (current_->parent())
+            {
+                sendToParent(event, current_->parent());
+            }
+            else
+            {
+                throw std::runtime_error("Event '" + event + "' not handled in state '" + current_->name() + "'");
+            }
+        }
+
+        void sendToParent(const std::string &event, const State *parent)
+        {
+            if (!parent)
+                return;
+            const auto &transitions = parent->transitions();
+            auto it = transitions.find(event);
+            if (it != transitions.end())
+            {
+                const auto &trans = it->second;
+                if (trans.guard && !trans.guard())
+                    return;
+                if (trans.action)
+                    trans.action();
+                current_ = find_state(trans.target);
+                if (current_ && current_->initial_substate())
+                {
+                    current_ = current_->find_substate(*current_->initial_substate());
+                }
+            }
+            else if (parent->parent())
+            {
+                sendToParent(event, parent->parent());
+            }
+            else
+            {
+                throw std::runtime_error("Event '" + event + "' not handled in parent state '" + parent->name() + "'");
             }
         }
 
-        const std::string &current_state() const
+        const State &current_state() const
         {
-            return current_state_;
+            return *current_;
         }
 
     private:
-        StateTree(std::unordered_map<std::string, State> states, std::string initial)
-            : states_(std::move(states)), current_state_(std::move(initial)) {}
+        std::list<State> states_;
+        const State *current_ = nullptr;
 
-        std::unordered_map<std::string, State> states_;
-        std::string current_state_;
+        const State *find_state(const std::string &name) const
+        {
+
+            if (!current_ || current_->parent() == nullptr)
+            {
+                for (const auto &s : states_)
+                {
+                    if (s.name() == name)
+                        return &s;
+                }
+                return nullptr;
+            }
+            else
+            {
+
+                auto foundState = current_->parent()->find_substate(name);
+                if (foundState)
+                {
+                    return foundState;
+                }
+
+                for (const auto &s : states_)
+                {
+                    if (s.name() == name)
+                        return &s;
+                }
+            }
+
+            return nullptr;
+        }
     };
 
 } // namespace CXXStateTree
diff --git a/include/CXXStateTree/Transition.hpp b/include/CXXStateTree/Transition.hpp
@@ -13,7 +13,7 @@ namespace CXXStateTree
     struct Transition
     {
         std::string target;
-        std::optional<Guard> guard;
-        std::optional<Action> action;
+        Guard guard = nullptr;
+        Action action = nullptr;
     };
 } // namespace CXXStateTree
diff --git a/tests/state_tree_test.cpp b/tests/state_tree_test.cpp

Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,6 @@`
`1`	`1`	`#pragma once`
`2`	`2`
	`3`	`+#include <list>`
`3`	`4`	`#include "StateTree.hpp"`
`4`	`5`
`5`	`6`	`namespace CXXStateTree`
`@@ -16,23 +17,25 @@ namespace CXXStateTree`
`16`	`17`
`17`	`18`	`Builder &state(const std::string &name, std::function<void(State &)> config)`
`18`	`19`	`{`
`19`		`- State s(name);`
`20`		`- config(s);`
`21`		`- states_.insert({name, std::move(s)});`
	`20`	`+ states_.emplace_back(name);`
	`21`	`+ config(states_.back());`
`22`	`22`	`return *this;`
`23`	`23`	`}`
`24`	`24`
`25`	`25`	`StateTree build()`
`26`	`26`	`{`
`27`		`- if (initial_state_.empty())`
	`27`	`+ StateTree tree;`
	`28`	`+ tree.states_ = std::move(states_);`
	`29`	`+ tree.current_ = tree.find_state(initial_state_);`
	`30`	`+ if (tree.current_ && tree.current_->initial_substate())`
`28`	`31`	`{`
`29`		`- throw std::runtime_error("Initial state not set");`
	`32`	`+ tree.current_ = tree.current_->find_substate(*tree.current_->initial_substate());`
`30`	`33`	`}`
`31`		`- return StateTree(states_, initial_state_);`
	`34`	`+ return tree;`
`32`	`35`	`}`
`33`	`36`
`34`	`37`	`private:`
`35`		`- std::unordered_map<std::string, State> states_;`
	`38`	`+ std::list<State> states_;`
`36`	`39`	`std::string initial_state_;`
`37`	`40`	`};`
`38`	`41`	`} // namespace CXXStateTree`