ErrorHandler using static array instead of vector

Author: Ultrawipf

Firmware/FFBoard/Inc/ErrorHandler.h

@@ -7,10 +7,15 @@
 
 #ifndef SRC_ERRORHANDLER_H_
 #define SRC_ERRORHANDLER_H_
-#include <vector>
+#include <array>
 #include <string>
 #include "thread.hpp"
 #include "CommandHandler.h"
+#include <span>
+
+#ifndef ERRORHANDLER_MAXERRORS
+#define ERRORHANDLER_MAXERRORS 16
+#endif
 
 /*
  * Error code definitions
@@ -49,24 +54,25 @@ enum class ErrorCode : uint32_t{
  * critical errors cause a shutdown or have to be cleared externally
  */
 enum class ErrorType : uint8_t{
-	warning,critical,temporary
+	none,warning,critical,temporary
 };
 
 class Error{
 public:
 	//Error(const Error &e);
+	Error(){}; // No error
 	Error(ErrorCode code, ErrorType type, std::string info) : code(code), type(type), info(info){};
 	ErrorCode code = ErrorCode::none;
-	ErrorType type = ErrorType::warning;
-	std::string info = "";
+	ErrorType type = ErrorType::none;
+	std::string info;
 
 	std::string toString();
 
 	/*
 	 * Errors are equivalent if their code and type match
 	 */
 	bool operator ==(const Error &b) const {return (this->code == b.code && this->type == b.type);}
-
+	bool isError() const {return this->code != ErrorCode::none && this->type != ErrorType::none;}
 };
 
 
@@ -86,10 +92,11 @@ class ErrorHandler {
 	static void clearTemp();
 	static void clearAll();
 
-	static std::vector<Error>* getErrors(); // Returns a vector of active errors
+	static std::span<Error> getErrors(); // Returns a vector of active errors
 
 protected:
-	static std::vector<Error> errors;
+	static std::array<Error,ERRORHANDLER_MAXERRORS> errors;
+	static void sortErrors();
 };
 
 /*

Firmware/FFBoard/Src/ErrorHandler.cpp

@@ -10,9 +10,11 @@
 #include "FFBoardMain.h"
 #include "cppmain.h"
 #include "critical.hpp"
+#include <span>
 
 std::vector<ErrorHandler*> ErrorHandler::errorHandlers;
-std::vector<Error> ErrorHandler::errors;
+//std::vector<Error> ErrorHandler::errors;
+std::array<Error,ERRORHANDLER_MAXERRORS> ErrorHandler::errors;
 
 
 std::string Error::toString(){
@@ -37,7 +39,7 @@ std::string Error::toString(){
 
 
 ErrorHandler::ErrorHandler(){
-	errors.reserve(10);
+//	errors.reserve(10);
 	addCallbackHandler(errorHandlers,this);
 }
 
@@ -54,7 +56,7 @@ void ErrorHandler::clearAll(){
 		for(Error& error : errors)
 			e->errorCallback(error, true);
 	}
-	errors.clear();
+	errors.fill(Error());
 }
 
 /*
@@ -63,10 +65,12 @@ void ErrorHandler::clearAll(){
 void ErrorHandler::clearTemp(){
 	for (uint8_t i = 0; i < errors.size(); i++){
 		if((errors)[i].type == ErrorType::temporary){
-			errors.erase(errors.begin()+i);
+			//errors.erase(errors.begin()+i);
+			errors[i] = Error(); // Empty
 			break;
 		}
 	}
+	sortErrors();
 }
 
 void ErrorHandler::addError(const Error &error){
@@ -75,7 +79,12 @@ void ErrorHandler::addError(const Error &error){
 			return;
 		}
 	}
-	errors.push_back(error);
+//	errors.push_back(error);
+	auto errIt = std::find_if(errors.begin(), errors.end(), [](const Error& err){return !err.isError();});
+	if(errIt != errors.end()){
+		*errIt = error; // If buffer is full do not store error but still call callbacks.
+	}
+
 
 	// Call all error handler with this error
 	//cpp_freertos::CriticalSection::SuspendScheduler();
@@ -88,7 +97,8 @@ void ErrorHandler::addError(const Error &error){
 void ErrorHandler::clearError(const Error &error){
 	for (uint8_t i = 0; i < errors.size(); i++){
 		if(errors[i] == error){
-			errors.erase(errors.begin()+i);
+//			errors.erase(errors.begin()+i);
+			errors[i] = Error(); // Empty
 			break;
 		}
 	}
@@ -97,6 +107,7 @@ void ErrorHandler::clearError(const Error &error){
 	for(ErrorHandler* e : errorHandlers){
 		e->errorCallback(error, true);
 	}
+	sortErrors();
 }
 
 /*
@@ -105,22 +116,31 @@ void ErrorHandler::clearError(const Error &error){
 void ErrorHandler::clearError(ErrorCode errorcode){
 	for (uint8_t i = 0; i < errors.size(); i++){
 		if(errors[i].code == errorcode){
-			errors.erase(errors.begin()+i);
+//			errors.erase(errors.begin()+i);
+			errors[i] = Error(); // Empty
 			for(ErrorHandler* e : errorHandlers){
 				e->errorCallback(errors[i], true);
 			}
 		}
 	}
+	sortErrors();
 }
 
-std::vector<Error>* ErrorHandler::getErrors(){
-	return &errors;
+std::span<Error> ErrorHandler::getErrors(){
+	return std::span<Error>(errors.begin(), std::find_if(errors.begin(), errors.end(), [](const Error& err){return err.type == ErrorType::none;}));
 }
 
 void ErrorHandler::errorCallback(const Error &error, bool cleared){
 
 }
 
+void ErrorHandler::sortErrors(){
+	auto errSortFun = [](const Error& a, const Error& b){
+		return a.code < b.code;
+	};
+	std::sort(errors.begin(),errors.end(),errSortFun);
+}
+
 
 //ClassIdentifier ErrorPrinter::info = {
 //	.name = "Errorprinter",

Firmware/FFBoard/Src/SystemCommands.cpp

@@ -319,16 +319,16 @@ void SystemCommands::replyFlashDump(std::vector<CommandReply>& replies){
  * Prints a formatted list of error conditions
  */
 void SystemCommands::replyErrors(std::vector<CommandReply>& replies){
-	std::vector<Error>* errors = ErrorHandler::getErrors();
-	if(errors->size() == 0){
+	std::span<Error> errors = ErrorHandler::getErrors();
+	if(errors.size() == 0){
 		CommandReply reply;
 		reply.reply += "None";
 		reply.type = CommandReplyType::STRING_OR_INT;
 		replies.push_back(reply);
 		return;
 	}
 
-	for(Error error : *errors){
+	for(Error error : errors){
 		CommandReply reply;
 		reply.reply += error.toString() + "\n";
 		reply.val = (uint32_t)error.code;