forstio/source/error.h

#pragma once

#include <string>
#include <variant>

namespace gin {
	class Error {
	private:
		std::string error_message;
		int8_t error_;
	public:
		Error();
		Error(const std::string& msg);
		Error(const std::string& msg, int8_t code);
		Error(const Error& error);

		const std::string& message() const;
		bool failed() const;

		bool isCritical() const;
		bool isRecoverable() const;
	};

	Error criticalError(const std::string& msg);
	Error recoverableError(const std::string& msg);
	Error noError();

	class ErrorOrValue {
	public:
		virtual ~ErrorOrValue() = default;
	};

	template<typename T>
	class ErrorOr : public ErrorOrValue {
	private:
		std::variant<T, Error> value_or_error;
	public:
		ErrorOr(const T& value):
			value_or_error{value}
		{}

		ErrorOr(T&& value):
			value_or_error{std::move(value)}
		{}

		ErrorOr(const Error& error):
			value_or_error{error}{}
		ErrorOr(Error&& error):
			value_or_error{std::move(error)}{}
	
		bool isValue() const {
			return std::holds_alternative<T>(value_or_error);
		}

		bool isError() const {
			return std::holds_alternative<Error>(value_or_error);
		}

		const Error& error() const {
			return std::get<Error>(value_or_error);
		}

		T& value() {
			return std::get<T>(value_or_error);
		}

		const T& value() const {
			return std::get<T>(value_or_error);
		}
	};
}