comin_error.cpp

Go to the documentation of this file.

// @file comin_error.cpp
// @brief Error handling functions
//
// @authors 01/2026 :: ICON Community Interface  <comin@icon-model.org>
//
// SPDX-License-Identifier: BSD-3-Clause
//
// See LICENSES for license information.
// Where software is supplied by third parties, it is indicated in the
// headers of the routines.
 
#include "comin_logging.hpp"
#include "comin_state.hpp"
#include "comin_util.hpp"
 
#include <mpi.h>
 
#include <algorithm>
#include <array>
#include <string_view>
#include <tuple>
 
static_assert(sizeof(t_comin_error_code) == sizeof(int),
              "The underlying type of t_comin_error_code must be int for "
              "Fortran interoperability. Recompile with "
              "-fno-short-enums or similar.");
 
namespace {
using namespace std::string_view_literals;
 
constexpr auto error_strings = comin::to_array<
    std::tuple<t_comin_error_code, std::string_view>>({
    {COMIN_SUCCESS, "Success"sv},
    {COMIN_INFO, "Info"sv},
    {COMIN_WARNING, "Warning"sv},
    {COMIN_ERROR_STATUS, "Error"sv},
    {COMIN_ERROR_CALLBACK_REGISTER_OUTSIDE_PRIMARYCONSTRUCTOR,
     "Callbacks cannot be registered after primary constructor."sv},
    {COMIN_ERROR_CALLBACK_COMPLETE,
     "Callback registration could not be completed."sv},
    {COMIN_ERROR_CALLBACK_EP_ID_UNKNOWN, "Unknown ID for entry point."sv},
    {COMIN_ERROR_DESCRDATA_SET_FCT_GLB2LOC,
     "Unable to set descriptive data function: glb2loc. Function not associated."sv},
    {COMIN_ERROR_DESCRDATA_FINALIZE,
     "Unable to clean up descriptive data structure (finalize)."sv},
    {COMIN_ERROR_METADATA_SET_OUTSIDE_PRIMARYCONSTRUCTOR,
     "Cannot set metadata outside primary constructor."sv},
    {COMIN_ERROR_METADATA_KEY_NOT_FOUND, "Metadata key not found."sv},
    {COMIN_ERROR_METADATA_GET_INSIDE_PRIMARYCONSTRUCTOR,
     "Unable to get metadata inside primary constructor."sv},
    {COMIN_ERROR_SETUP_FINALIZE, "Setup finalized failed."sv},
    {COMIN_ERROR_SETUP_COMIN_ALREADY_INITIALIZED,
     "ComIn is already initilized."sv},
    {COMIN_ERROR_SETUP_ERRHANDLER_NOT_ASSOCIATED,
     "The host model error handler procedure cannot be found."sv},
    {COMIN_ERROR_SETUP_ERRHANDLER_NOT_SET,
     "Error handler not set (setup check)."sv},
    {COMIN_ERROR_SETUP_PRECISION_TEST_FAILED,
     "Precision test failed (setup check)."sv},
    {COMIN_ERROR_VAR_REQUEST_AFTER_PRIMARYCONSTRUCTOR,
     "Variables cannot be requested after primary constructor."sv},
    {COMIN_ERROR_VAR_REQUEST_EXISTS_IS_LMODEXCLUSIVE,
     "Requested variable already exists and is exclusive."sv},
    {COMIN_ERROR_VAR_REQUEST_EXISTS_REQUEST_LMODEXCLUSIVE,
     "Requested exclusive variable already exists."sv},
    {COMIN_ERROR_VAR_DESCRIPTOR_NOT_FOUND, "var_descriptor not found."sv},
    {COMIN_ERROR_VAR_ITEM_NOT_ASSOCIATED, "var_item not associated."sv},
    {COMIN_ERROR_FIELD_NOT_ALLOCATED, "Field not allocated."sv},
    {COMIN_ERROR_POINTER_NOT_ASSOCIATED, "Pointer not associated."sv},
    {COMIN_ERROR_TRACER_REQUEST_NOT_FOR_ALL_DOMAINS,
     "Tracers need to be requested for all domains (id=-1)."sv},
    {COMIN_ERROR_VAR_SYNC_DEVICE_MEM_NOT_ASSOCIATED,
     "Sync device memory callback not set (setup check)."sv},
    {COMIN_ERROR_VAR_SYNC_HALO_NOT_ASSOCIATED,
     "Sync halo callback not set (setup check)."sv},
    {COMIN_ERROR_VAR_GET_OUTSIDE_SECONDARY_CONSTRUCTOR,
     "Cannot get variable outside of secondary constructor."sv},
    {COMIN_ERROR_VAR_GET_NO_DEVICE, "No device available."sv},
    {COMIN_ERROR_VAR_GET_VARIABLE_NOT_FOUND, "Cannot find variable."sv},
    {COMIN_ERROR_VAR_GET_CONTAINER_CAN_NOT_HALO_SYNCHRONIZED,
     "Cannot halo sync a container."sv},
    {COMIN_ERROR_VAR_GET_IRREGULAR_VAR_CAN_NOT_HALO_SYNCHRONIZED,
     "Cannot halo sync an irregular variable."sv},
    {COMIN_ERROR_VAR_SYNC_HALO_NOT_SUPPORTED_ZAXIS,
     "Can only halo sync vars on 2D or 3D vertical grid."sv},
    {COMIN_ERROR_VAR_METADATA_INCONSISTENT_TYPE,
     "Metadata type does not match access function."sv},
    {COMIN_ERROR_VAR_GET_VARIABLE_WRONG_TYPE,
     "Wrong type used requesting the pointer of a variable."sv},
    {COMIN_ERROR_INDEX_OUT_OF_BOUNDS, "Index out of bounds."sv},
    {COMIN_ERROR_DESCRDATA_TIMESTEPLENGTH_NOT_SET, "timesteplength not set"},
    {COMIN_ERROR_FATAL, "Fatal error."sv},
});
} // namespace
 
namespace comin::error {
std::string_view to_string(t_comin_error_code error_code) {
  auto it = std::find_if(
      error_strings.cbegin(), error_strings.cend(),
      [error_code](const auto& a) { return std::get<0>(a) == error_code; });
 
  if (error_strings.cend() != it) {
    return std::get<1>(*it);
  } else {
    return "<unknown>"sv;
  }
}
 
std::string_view category(t_comin_error_code error_code) {
  if (COMIN_SUCCESS == error_code)
    return "SUCCESS"sv;
  else if (error_code < COMIN_WARNING)
    return "INFO"sv;
  else if (error_code < COMIN_ERROR_STATUS)
    return "WARNING"sv;
  else if (error_code < COMIN_ERROR_FATAL)
    return "ERROR"sv;
  else
    return "FATAL ERROR"sv;
}
} // namespace comin::error
 
extern "C" {

  t_comin_error_code comin_error_get() {
    return static_cast<t_comin_error_code>(comin_state_get_error_code());
  }

  void comin_error_reset() { comin_state_set_error_code(COMIN_SUCCESS); }

  const char* comin_error_get_string(t_comin_error_code error_code) {
    return comin::error::to_string(error_code).data();
  }

  const char* comin_error_get_category(t_comin_error_code error_code) {
    return comin::error::category(error_code).data();
  }

  void comin_plugin_finish(const char* routine, const char* text) {
 
    if (comin_current_get_ep() == EP_FINISH)
      return; // dont call finish again if we already in EP_FINISH
 
    if (!comin::state.comin_host_errhandler_fct) {
      // Fallback (best we could do before the errhandler is set)
      comin::logging::message(12, routine, ": ", text);
      int exit_no = 1;
      MPI_Abort(MPI_COMM_WORLD, exit_no);
      exit(exit_no);
    } else {
      comin::state.comin_host_errhandler_fct(routine, text);
    }
  }
 
  /*
    check the error code:
    does nothing if error_code == COMIN_SUCCESS
    prints the corresponding message
    calls comin_plugin_finish if the error_code is an error or fatal error
  */
  void comin_error_check() {
    int plugin_id                 = comin_current_get_plugin_id();
    t_comin_error_code error_code = comin_error_get();
    if (error_code == COMIN_SUCCESS)
      return;
 
    const char* category = comin_error_get_category(error_code);
    const char* msg      = comin_error_get_string(error_code);
    if (error_code < COMIN_ERROR_STATUS) {
      comin::logging::message(12, category, ": ", msg);
    } else {
      if (plugin_id > 0) {
        comin_plugin_finish_f("ComIn", "%s: %s", category, msg);
      } else {
        comin_plugin_finish_f(comin_current_get_plugin_name(), "%s: %s",
                              category, msg);
      }
    }
  }
 
  /*
    Set the internal error code to errcode. If the error handling mode is set to
    automatic (default), calls comin_error_check to handle the error
    immediately.
  */
  void comin_error_set(t_comin_error_code error_code) {
    comin_state_set_error_code(error_code);
    int plugin_id = comin_current_get_plugin_id();
    if (plugin_id < 1 || !comin_current_get_plugin_errors_return())
      comin_error_check();
  }
}
 
namespace {
constexpr bool check_all_error_codes_have_strings() {
  for (size_t code = 0; code <= COMIN_ERROR_FATAL; ++code) {
    bool found = false;
    for (const auto& it : error_strings) {
      if (std::get<0>(it) == code) {
        found = true;
        break;
      }
    }
 
    if (!found) {
      return false;
    }
  }
 
  return true;
}
 
static_assert(check_all_error_codes_have_strings(),
              "Not all error codes have error strings.");
 
constexpr bool check_all_error_codes_have_one_string() {
  for (size_t code = 0; code <= COMIN_ERROR_FATAL; ++code) {
    unsigned nfound = 0;
    for (const auto& it : error_strings) {
      if (std::get<0>(it) == code) {
        ++nfound;
      }
    }
 
    if (nfound != 1) {
      return false;
    }
  }
 
  return true;
}
 
static_assert(check_all_error_codes_have_one_string(),
              "Some error codes have multiple strings.");
 
} // namespace