Compile time State Machine (#549)

* Full of errors, but moving forward

* Avanzando bien fino, casi implementado

* Vamos bien encaminados

* Bruh

* Casi compila, casi

* StateMachine compila, otras cosas no xd

* Some error fixing

* Se lleva el credito su prima en tanga

* Compila por ahora??

* Compiles without state orders

* Fixed StateOrder problems and some fixes on the state machine code

* Now everything (nearly) is consteval

* New concepts added to ensure StateEnum is a enum

* Much more checks with concepts, implemented scheduler logic

* Testing needed, but might work

* Functional version?

* State Machine now works!!

* Moved static_vector to a seperate file

Author: Cantonplas

Inc/C++Utilities/StaticVector.hpp

@@ -0,0 +1,53 @@
+#pragma once
+#include <array>
+#include "ErrorHandler/ErrorHandler.hpp"
+
+template <typename T, size_t Capacity>
+class StaticVector {
+ private: 
+    std::array<T, Capacity> data{};
+    size_t size_ = 0;
+
+public:
+    constexpr StaticVector() = default;
+    
+    template<typename... Args>
+    constexpr StaticVector(Args&&... args) : data{std::forward<Args>(args)...}, size_(sizeof...(args)) {}
+
+    constexpr bool operator==(const StaticVector&) const = default;
+
+    constexpr void push_back(const T& value) 
+    {
+        if (size_ >= Capacity) 
+        {
+            ErrorHandler("StaticVector capacity exceeded");
+            return;
+        }        
+        data[size_] = value;
+        size_++;
+    }
+
+    constexpr auto begin() { return data.begin(); }
+    constexpr auto begin() const { return data.begin(); }
+    constexpr auto end() { return data.begin() + size_; } 
+    constexpr auto end() const { return data.begin() + size_; } 
+    
+    constexpr const std::array<T, Capacity>& get_array() const { return data; }
+    constexpr size_t size() const { return size_; }
+    constexpr T* get_data() { return data.data(); }
+    constexpr const T* get_data() const { return data.data(); }
+    constexpr  T& operator[](size_t i) { return data[i]; }
+    constexpr  const T& operator[](size_t i) const { return data[i]; }
+    constexpr bool contains(const T& value) const 
+    {
+        for (size_t i = 0; i < size_; ++i) 
+        {
+            if (data[i] == value) 
+            {
+                return true;
+            }
+        }
+        return false;
+    }
+};
+

Inc/ST-LIB_HIGH/Protections/ProtectionManager.hpp

@@ -42,7 +42,7 @@ class ProtectionManager {
 
     static void set_id(Boards::ID id);
 
-    static void link_state_machine(StateMachine& general_state_machine,
+    static void link_state_machine(IStateMachine& general_state_machine,
                                    state_id fault_id);
 
     template <class Type, ProtectionType... Protector,
@@ -84,7 +84,7 @@ class ProtectionManager {
     static Boards::ID board_id;
     static vector<Protection> low_frequency_protections;
     static vector<Protection> high_frequency_protections;
-    static StateMachine* general_state_machine;
+    static IStateMachine* general_state_machine;
     static state_id fault_state_id;
 
     static Notification fault_notification;

Inc/ST-LIB_LOW/StateMachine/HeapStateOrder.hpp

@@ -1,19 +1,20 @@
 #pragma once
 #include "StateMachine/StateOrder.hpp"
 
+template<class StateMachineType>
 class HeapStateOrder : public HeapOrder{
 public:
-	StateMachine& state_machine;
-	StateMachine::state_id state;
+	StateMachineType& state_machine;
+	typename StateMachineType::state_id state;
 
     template<class... Types>
-	HeapStateOrder(uint16_t id,void(*callback)(void), StateMachine& state_machine, StateMachine::state_id state,Types*... values) : HeapOrder(id,callback,values...),
+	HeapStateOrder(uint16_t id,void(*callback)(void), StateMachineType& state_machine, typename StateMachineType::state_id state,Types*... values) : HeapOrder(id,callback,values...),
     		state_machine(state_machine), state(state) {
     	if(not state_machine.get_states().contains(state)){
     		ErrorHandler("State Machine does not contain state, cannot add StateOrder");
     		return;
     	}
-    	else state_machine.get_states()[state].add_state_order(id);
+    	else state_machine.get_states()[static_cast<size_t>(state)].add_state_order(id);
     	orders[id] = this;
     }
 
@@ -24,4 +25,7 @@ class HeapStateOrder : public HeapOrder{
     void parse(OrderProtocol* socket, uint8_t* data)override{
     	if(state_machine.is_on && state_machine.current_state == state) HeapOrder::parse(data);
     }
-};
+};
+
+template<class StateMachineType, class... Types>
+HeapStateOrder(uint16_t, void(*)(void), StateMachineType&, typename StateMachineType::state_id, Types*...) -> HeapStateOrder<StateMachineType>;

Inc/ST-LIB_LOW/StateMachine/StackStateOrder.hpp

@@ -1,18 +1,18 @@
 #pragma once
 #include "StateMachine/StateOrder.hpp"
 
-template<size_t BufferLength,class... Types> requires NotCallablePack<Types*...>
+template<class StateMachineType, size_t BufferLength,class... Types> requires NotCallablePack<Types*...>
 class StackStateOrder : public StackOrder<BufferLength,Types...>{
 public:
-	StateMachine& state_machine;
-	StateMachine::state_id state;
-    StackStateOrder(uint16_t id,void(*callback)(void), StateMachine& state_machine, StateMachine::state_id state,Types*... values) : StackOrder<BufferLength,Types...>(id,callback,values...),
+	StateMachineType& state_machine;
+	typename StateMachineType::state_id state;
+    StackStateOrder(uint16_t id,void(*callback)(void), StateMachineType& state_machine, typename StateMachineType::state_id state,Types*... values) : StackOrder<BufferLength,Types...>(id,callback,values...),
     		state_machine(state_machine), state(state) {
     	if(not state_machine.get_states().contains(state)){
     		ErrorHandler("State Machine does not contain state, cannot add StateOrder");
     		return;
     	}
-    	else state_machine.get_states()[state].add_state_order(id);
+    	else state_machine.get_states()[static_cast<size_t>(state)].add_state_order(id);
     	Order::orders[id] = this;
     }
 
@@ -26,6 +26,6 @@ class StackStateOrder : public StackOrder<BufferLength,Types...>{
 };
 
 #if __cpp_deduction_guides >= 201606
-template<class... Types> requires NotCallablePack<Types*...>
-StackStateOrder(uint16_t id,void(*callback)(void), StateMachine& state_machine, StateMachine::state_id state,Types*... values)->StackStateOrder<(!has_container<Types...>::value)*total_sizeof<Types...>::value, Types...>;
-#endif
+template<class StateMachineType, class... Types> requires NotCallablePack<Types*...>
+StackStateOrder(uint16_t id,void(*callback)(void), StateMachineType& state_machine, typename StateMachineType::state_id state,Types*... values)->StackStateOrder<StateMachineType, (!has_container<Types...>::value)*total_sizeof<Types...>::value, Types...>;
+#endif