ValidationResult.hpp

Go to the documentation of this file.

#pragma once

 
#include <string>
#include <vector>
 
namespace icarus {

enum class ValidationSeverity {
    Error,   
    Warning, 
    Info     
};

struct ValidationIssue {
    ValidationSeverity severity;
    std::string message;
    std::string context; 
 
    ValidationIssue(ValidationSeverity sev, std::string msg, std::string ctx = "")
        : severity(sev), message(std::move(msg)), context(std::move(ctx)) {}

    [[nodiscard]] bool IsError() const { return severity == ValidationSeverity::Error; }
};

class ValidationResult {
  public:
    ValidationResult() = default;

    [[nodiscard]] bool IsValid() const {
        for (const auto &issue : issues_) {
            if (issue.IsError()) {
                return false;
            }
        }
        return true;
    }

    [[nodiscard]] std::vector<std::string> GetErrors() const {
        std::vector<std::string> errors;
        for (const auto &issue : issues_) {
            if (issue.severity == ValidationSeverity::Error) {
                errors.push_back(FormatIssue(issue));
            }
        }
        return errors;
    }

    [[nodiscard]] std::vector<std::string> GetWarnings() const {
        std::vector<std::string> warnings;
        for (const auto &issue : issues_) {
            if (issue.severity == ValidationSeverity::Warning) {
                warnings.push_back(FormatIssue(issue));
            }
        }
        return warnings;
    }

    [[nodiscard]] std::vector<std::string> GetInfos() const {
        std::vector<std::string> infos;
        for (const auto &issue : issues_) {
            if (issue.severity == ValidationSeverity::Info) {
                infos.push_back(FormatIssue(issue));
            }
        }
        return infos;
    }

    [[nodiscard]] const std::vector<ValidationIssue> &GetIssues() const { return issues_; }

    void AddError(const std::string &message, const std::string &context = "") {
        issues_.emplace_back(ValidationSeverity::Error, message, context);
    }

    void AddWarning(const std::string &message, const std::string &context = "") {
        issues_.emplace_back(ValidationSeverity::Warning, message, context);
    }

    void AddInfo(const std::string &message, const std::string &context = "") {
        issues_.emplace_back(ValidationSeverity::Info, message, context);
    }

    [[nodiscard]] bool HasIssues() const { return !issues_.empty(); }

    [[nodiscard]] size_t ErrorCount() const {
        size_t count = 0;
        for (const auto &issue : issues_) {
            if (issue.IsError()) {
                ++count;
            }
        }
        return count;
    }

    [[nodiscard]] size_t WarningCount() const {
        size_t count = 0;
        for (const auto &issue : issues_) {
            if (issue.severity == ValidationSeverity::Warning) {
                ++count;
            }
        }
        return count;
    }
 
  private:
    std::vector<ValidationIssue> issues_;
 
    [[nodiscard]] static std::string FormatIssue(const ValidationIssue &issue) {
        if (issue.context.empty()) {
            return issue.message;
        }
        return issue.message + " [" + issue.context + "]";
    }
};
 
} // namespace icarus