errors.hpp

#ifndef LPINTERFACE_ERRORS_H
#define LPINTERFACE_ERRORS_H

#include <exception>
#include <iostream>
#include <sstream>

namespace lpint {

class LpException : public std::runtime_error {
 public:
  explicit LpException(const char *msg) : std::runtime_error(msg) {}

  template <typename... Args>
  explicit LpException(Args &&... args)
      : std::runtime_error(std::forward<Args>(args)...) {}
};

class NotImplementedError : public LpException {
 public:
  NotImplementedError() : LpException("Feature not implemented") {}
};

class ModelNotSolvedException : public LpException {
 public:
  ModelNotSolvedException() : LpException("Model has not yet been solved") {}
};

class UnsupportedParameterException : public LpException {
 public:
  UnsupportedParameterException()
      : LpException("Invalid parameter was supplied") {}
};

class UnsupportedConstraintException : public LpException {
 public:
  UnsupportedConstraintException()
      : LpException("Unsupported constraint type was supplied") {}
};

class InvalidMatrixEntryException : public LpException {
 public:
  InvalidMatrixEntryException()
      : LpException(
            "Invalid matrix entry; does your row/column contain duplicate "
            "indices?") {}
};

class UnsupportedVariableTypeException : public LpException {
 public:
  UnsupportedVariableTypeException()
      : LpException("Unsupported variable type for this backend") {}
};

class InvalidVariableBoundsException : public LpException {
  public:
   InvalidVariableBoundsException()
      : LpException("Variable lower bound should be smaller than upper bound") {}
};

class GurobiException : public LpException {
 public:
  explicit GurobiException(int code)
      : LpException("Error occured in Gurobi, code " + std::to_string(code)),
        code_(code) {}

  GurobiException(int code, const char *msg)
      : LpException("Error occured in Gurobi, code " + std::to_string(code) +
                    " - " + std::string(msg)),
        code_(code) {}

  int code() const { return code_; }

 private:
  int code_;
};

class UnknownStatusException : public LpException {
 public:
  explicit UnknownStatusException(int code)
      : LpException("Unknown status code encountered: " +
                    std::to_string(code)) {}
};

class UnsupportedFeatureException : public LpException {
 public:
  UnsupportedFeatureException()
      : LpException("Feature not available for this solver backend") {}
};

class FailedToSetParameterException : public LpException {
 public:
  FailedToSetParameterException()
      : LpException("Failed to set an LP solver parameter") {}
};

class SoplexException : public LpException {
 public:
  SoplexException() : LpException("SoPlex ran into an error solving an LP") {}
};

class MismatchedDimensionsException : public LpException {
 public:
  MismatchedDimensionsException()
      : LpException("Array dimensions mismatched") {}
};

enum class Status : int {
  NotLoaded,
  NoInformation,
  Optimal,
  Infeasible,
  InfeasibleOrUnbounded,
  Unbounded,
  Cutoff,
  IterationLimit,
  NodeLimit,
  TimeOut,
  SolutionLimit,
  Interrupted,
  NumericFailure,
  SuboptimalSolution,
  InProgress,
  UserObjectiveLimit,
  NoRatioTester,
  NoPricer,
  NoSolver,
  ExitDecomposition,
  Decomposition,
  Cycling,
  OptimalUnscaledViolations,
  NotInitialized,
  ObjectiveLimit,
  Regular,
};

// LCOV_EXCL_START
inline std::ostream &operator<<(std::ostream &os, const Status &status) {
  os << static_cast<int>(status);
  return os;
}
// LCOV_EXCL_STOP

}  // namespace lpint

#endif  // LPINTERFACE_ERRORS_H