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- "));
    }
  }
 
  explicit operator bool() const noexcept;
 
  std::vector<std::string> errors;
 
  std::vector<std::string> warnings;
};
 
} // namespace CesiumUtility