ErrorList.h

#pragma once
 
#include <CesiumUtility/Library.h>
#include <CesiumUtility/Log.h> // NOLINT
#include <CesiumUtility/joinToString.h>
 
#include <spdlog/spdlog.h>
 
#include <string>
#include <vector>
 
namespace CesiumUtility {

struct CESIUMUTILITY_API ErrorList {
  static ErrorList error(std::string errorMessage);

  static ErrorList warning(std::string warningMessage);

  void merge(const ErrorList& errorList);

  void merge(ErrorList&& errorList);

  template <typename ErrorStr> void emplaceError(ErrorStr&& error) {
    errors.emplace_back(std::forward<ErrorStr>(error));
  }

  template <typename WarningStr> void emplaceWarning(WarningStr&& warning) {
    warnings.emplace_back(std::forward<WarningStr>(warning));
  }

  bool hasErrors() const noexcept;

  template <typename PromptStr>
  void logError(
      const std::shared_ptr<spdlog::logger>& pLogger,
      PromptStr&& prompt) const noexcept {
    if (!errors.empty()) {
      SPDLOG_LOGGER_ERROR(
          pLogger,
          "{}:\n- {}",
          std::forward<PromptStr>(prompt),
          CesiumUtility::joinToString(errors, "\n- "));
    }
  }

  template <typename PromptStr>
  void logWarning(
      const std::shared_ptr<spdlog::logger>& pLogger,
      PromptStr&& prompt) const noexcept {
    if (!warnings.empty()) {
      SPDLOG_LOGGER_WARN(
          pLogger,
          "{}:\n- {}",
          std::forward<PromptStr>(prompt),
          CesiumUtility::joinToString(warnings, "\n- "));
    }
  }

  template <typename PromptStr>
  void
  log(const std::shared_ptr<spdlog::logger>& pLogger,
      PromptStr&& prompt) const noexcept {
    if (!this->errors.empty()) {
      SPDLOG_LOGGER_ERROR(
          pLogger,
          this->format(std::forward<PromptStr>(prompt)));
    } else if (!this->warnings.empty()) {
      SPDLOG_LOGGER_WARN(
          pLogger,
          this->format(std::forward<PromptStr>(prompt)));
    }
  }

  template <typename PromptStr>
  std::string format(PromptStr&& prompt) const noexcept {
    if (this->warnings.empty() && this->errors.empty()) {
      return std::string();
    }
 
    std::string result = prompt;
 
    if (!this->errors.empty()) {
      result += "\n- [Error] " +
                CesiumUtility::joinToString(this->errors, "\n- [Error] ");
    }
 
    if (!this->warnings.empty()) {
      result += "\n- [Warning] " +
                CesiumUtility::joinToString(this->warnings, "\n- [Warning] ");
    }
 
    return result;
  }

  explicit operator bool() const noexcept;

  std::vector<std::string> errors;

  std::vector<std::string> warnings;
};
 
} // namespace CesiumUtility