exit_status.hpp

// Copyright (c) Sleipnir contributors
 
#pragma once
 
#include <stdint.h>
 
#include <format>
#include <utility>
 
namespace slp {
 
enum class ExitStatus : int8_t {
  SUCCESS = 0,
  CALLBACK_REQUESTED_STOP = 1,
  TOO_FEW_DOFS = -1,
  LOCALLY_INFEASIBLE = -2,
  GLOBALLY_INFEASIBLE = -3,
  FACTORIZATION_FAILED = -4,
  LINE_SEARCH_FAILED = -5,
  NONFINITE_INITIAL_COST_OR_CONSTRAINTS = -6,
  DIVERGING_ITERATES = -7,
  MAX_ITERATIONS_EXCEEDED = -8,
  TIMEOUT = -9,
};
 
}  // namespace slp
 
template <>
struct std::formatter<slp::ExitStatus> {
  constexpr auto parse(std::format_parse_context& ctx) {
    return m_underlying.parse(ctx);
  }
 
  template <typename FmtContext>
  auto format(const slp::ExitStatus& exit_status, FmtContext& ctx) const {
    using enum slp::ExitStatus;
 
    switch (exit_status) {
      case SUCCESS:
        return m_underlying.format("success", ctx);
      case CALLBACK_REQUESTED_STOP:
        return m_underlying.format("callback requested stop", ctx);
      case TOO_FEW_DOFS:
        return m_underlying.format("too few degrees of freedom", ctx);
      case LOCALLY_INFEASIBLE:
        return m_underlying.format("locally infeasible", ctx);
      case GLOBALLY_INFEASIBLE:
        return m_underlying.format("globally infeasible", ctx);
      case FACTORIZATION_FAILED:
        return m_underlying.format("factorization failed", ctx);
      case LINE_SEARCH_FAILED:
        return m_underlying.format("line search failed", ctx);
      case NONFINITE_INITIAL_COST_OR_CONSTRAINTS:
        return m_underlying.format("nonfinite initial cost or constraints",
                                   ctx);
      case DIVERGING_ITERATES:
        return m_underlying.format("diverging iterates", ctx);
      case MAX_ITERATIONS_EXCEEDED:
        return m_underlying.format("max iterations exceeded", ctx);
      case TIMEOUT:
        return m_underlying.format("timeout", ctx);
      default:
        std::unreachable();
    }
  }
 
 private:
  std::formatter<const char*> m_underlying;
};