exceptions.h

Go to the documentation of this file.

/****************************************************************************
 *   This file is part of the aGrUM/pyAgrum library.                        *
 *                                                                          *
 *   Copyright (c) 2005-2025 by                                             *
 *       - Pierre-Henri WUILLEMIN(_at_LIP6)                                 *
 *       - Christophe GONZALES(_at_AMU)                                     *
 *                                                                          *
 *   The aGrUM/pyAgrum library is free software; you can redistribute it    *
 *   and/or modify it under the terms of either :                           *
 *                                                                          *
 *    - the GNU Lesser General Public License as published by               *
 *      the Free Software Foundation, either version 3 of the License,      *
 *      or (at your option) any later version,                              *
 *    - the MIT license (MIT),                                              *
 *    - or both in dual license, as here.                                   *
 *                                                                          *
 *   (see https://agrum.gitlab.io/articles/dual-licenses-lgplv3mit.html)    *
 *                                                                          *
 *   This aGrUM/pyAgrum library is distributed in the hope that it will be  *
 *   useful, but WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,          *
 *   INCLUDING BUT NOT LIMITED TO THE WARRANTIES MERCHANTABILITY or FITNESS *
 *   FOR A PARTICULAR PURPOSE  AND NONINFRINGEMENT. IN NO EVENT SHALL THE   *
 *   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER *
 *   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,        *
 *   ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR  *
 *   OTHER DEALINGS IN THE SOFTWARE.                                        *
 *                                                                          *
 *   See LICENCES for more details.                                         *
 *                                                                          *
 *   SPDX-FileCopyrightText: Copyright 2005-2025                            *
 *       - Pierre-Henri WUILLEMIN(_at_LIP6)                                 *
 *       - Christophe GONZALES(_at_AMU)                                     *
 *   SPDX-License-Identifier: LGPL-3.0-or-later OR MIT                      *
 *                                                                          *
 *   Contact  : info_at_agrum_dot_org                                       *
 *   homepage : http://agrum.gitlab.io                                      *
 *   gitlab   : https://gitlab.com/agrumery/agrum                           *
 *                                                                          *
 ****************************************************************************/
 

#ifndef GUM_EXCEPTIONS_H
#define GUM_EXCEPTIONS_H
// WARNING : Do not include this file directly : instead include
// <agrum/config.h>
 
#include <iomanip>
#include <iostream>
#include <string>
#include <utility>
 
#include <agrum/base/core/types.h>
 
#define GUM_ERROR_IN_EXPR(type, msg) throw(type(msg))
 
#if defined(SWIG) || defined(GUM_FOR_SWIG)
// msg can be a string or a sequence "x<<y<<z"
#  define GUM_ERROR(type, msg)       \
    {                                \
      std::ostringstream err_stream; \
      err_stream << msg;             \
      throw(type(err_stream.str())); \
    }
#  define GUM_SHOWERROR(e) \
    { std::cout << std::endl << (e).what() << std::endl; }
#else   // defined(SWIG) || defined(GUM_FOR_SWIG)
#  define GUM_ERROR(type, msg)                                                             \
    {                                                                                      \
      std::ostringstream error_stream;                                                     \
      error_stream << msg;                                                                 \
      throw(type(gum::_createMsg_(__FILE__, __FUNCTION__, __LINE__, error_stream.str()))); \
    }
#  ifdef GUM_DEBUG_MODE
#    define GUM_SHOWERROR(e)                                                                     \
      {                                                                                          \
        std::cout << std::endl << __FILE__ << ":" << __LINE__ << " " << (e).what() << std::endl; \
        std::cout << (e).errorCallStack() << std::endl;                                          \
      }
#  else    // GUM_DEBUG_MODE
#    define GUM_SHOWERROR(e) \
      { std::cout << std::endl << __FILE__ << ":" << __LINE__ << " " << (e).what() << std::endl; }
#  endif   // GUM_DEBUG_MODE
#endif     //  defined(SWIG) || defined(GUM_FOR_SWIG)
 
#define GUM_MAKE_ERROR(TYPE, SUPERCLASS, MSG)                                \
  class TYPE: public SUPERCLASS {                                            \
    public:                                                                  \
    explicit TYPE(const std::string& aMsg, const std::string& aType = MSG) : \
        SUPERCLASS(aMsg, aType) {};                                          \
    TYPE(const TYPE& src) : SUPERCLASS(src) {};                              \
  };
 
#ifdef GUM_FOR_SWIG
#  define GUM_SYNTAX_ERROR(msg, filename, line, column)                    \
    {                                                                      \
      std::ostringstream error_stream;                                     \
      error_stream << msg;                                                 \
      throw(gum::SyntaxError(error_stream.str(), filename, line, column)); \
    }
#else   // GUM_FOR_SWIG
#  define GUM_SYNTAX_ERROR(msg, filename, line, column)                    \
    {                                                                      \
      std::ostringstream error_stream;                                     \
      error_stream << msg;                                                 \
      throw(gum::SyntaxError(error_stream.str(), filename, line, column)); \
    }
#endif   // GUM_FOR_SWIG
 
namespace gum {
  class Exception: public std::exception {
    protected:
    std::string msg_;
    std::string type_;
    std::string callstack_;
    std::string what_;
 
    public:
    // ====================================================================
    // ====================================================================
    explicit Exception(std::string aMsg = "", std::string aType = "Generic error");
 
    Exception(const Exception& e);
 
    virtual ~Exception() = default;

 
    GUM_NODISCARD const char* what() const noexcept override { return what_.c_str(); };

    GUM_NODISCARD std::string errorContent() const { return msg_; };

    GUM_NODISCARD std::string errorType() const { return type_; };

    GUM_NODISCARD std::string errorCallStack() const { return callstack_; };
  };
 

  class FatalError;

  class IteratorError;

  class UndefinedIteratorValue;

  class UndefinedIteratorKey;

  class NullElement;

  class UndefinedElement;

  class SizeError;
 

  class InvalidArgumentsNumber;

  class InvalidArgument;

  class IOError;

  class FormatNotFound;

  class OperationNotAllowed;

  class NotFound;

  class ArgumentError;

  class OutOfBounds;

  class DuplicateElement;

  class DuplicateLabel;


  class GraphError;

  class NoNeighbour;

  class NoParent;

  class NoChild;

  class InvalidEdge;

  class InvalidArc;

  class InvalidNode;

  class DefaultInLabel;

  class InvalidDirectedCycle;


  class CPTError;


  class ScheduleMultiDimError;

  class AbstractScheduleMultiDim;

  class UnknownScheduleMultiDim;

  class DuplicateScheduleMultiDim;

  class ScheduleOperationError;

  class UnknownScheduleOperation;

  class UnavailableScheduleOperation;

  class UnexecutedScheduleOperation;

  class IncompatibleEvidence;

  class FactoryError;

  class FactoryInvalidState;

  class TypeError;

  class WrongClassElement;

  class PRMTypeError;

  class LearningError;

  class IncompatibleScorePrior;

  class PossiblyIncompatibleScorePrior;

  class DatabaseError;

  class MissingVariableInDatabase;

  class UnknownLabelInDatabase;

  class MissingValueInDatabase;
 

  class SyntaxError;

  class NotImplementedYet;
 
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
  std::string _createMsg_(const std::string& filename,
                          const std::string& function,
                          int                line,
                          const std::string& msg);
 
  GUM_MAKE_ERROR(FatalError, Exception, "Fatal error")
 
  GUM_MAKE_ERROR(NotImplementedYet, Exception, "Not implemented yet")
 
  GUM_MAKE_ERROR(IteratorError, Exception, "Error in iterator")
 
  GUM_MAKE_ERROR(UndefinedIteratorValue, IteratorError, "Undefined iterator")
 
  GUM_MAKE_ERROR(UndefinedIteratorKey, IteratorError, "Undefined iterator's key")
 
  GUM_MAKE_ERROR(NullElement, Exception, "Null element")
 
  GUM_MAKE_ERROR(UndefinedElement, Exception, "Undefined element")
 
  GUM_MAKE_ERROR(SizeError, Exception, "incorrect size")
 
  GUM_MAKE_ERROR(ArgumentError, Exception, "Argument error")
 
  GUM_MAKE_ERROR(InvalidArgumentsNumber, ArgumentError, "Invalid argument number")
 
  GUM_MAKE_ERROR(InvalidArgument, ArgumentError, "Invalid argument")
 
  GUM_MAKE_ERROR(IOError, Exception, "I/O Error")
 
  GUM_MAKE_ERROR(FormatNotFound, IOError, "Format not found")
 
  GUM_MAKE_ERROR(OperationNotAllowed, Exception, "Operation not allowed")
 
  GUM_MAKE_ERROR(NotFound, Exception, "Object not found")
 
  GUM_MAKE_ERROR(OutOfBounds, ArgumentError, "Out of bound error")
 
  GUM_MAKE_ERROR(DuplicateElement, ArgumentError, "Duplicate element")
 
  GUM_MAKE_ERROR(DuplicateLabel, ArgumentError, "Duplicate label")
 
  GUM_MAKE_ERROR(GraphError, Exception, "Graph error")
 
  GUM_MAKE_ERROR(NoNeighbour, GraphError, "No neighbour found")
 
  GUM_MAKE_ERROR(NoParent, GraphError, "No parent found")
 
  GUM_MAKE_ERROR(NoChild, GraphError, "No child found")
 
  GUM_MAKE_ERROR(InvalidEdge, GraphError, "Invalid edge")
 
  GUM_MAKE_ERROR(InvalidArc, GraphError, "Invalid arc")
 
  GUM_MAKE_ERROR(InvalidNode, GraphError, "Invalid node")
 
  GUM_MAKE_ERROR(DefaultInLabel, GraphError, "Error on label")
 
  GUM_MAKE_ERROR(InvalidDirectedCycle, GraphError, "Directed cycle detected")
 
  GUM_MAKE_ERROR(InvalidPartiallyDirectedCycle, GraphError, "Partially directed cycle detected")
 
  GUM_MAKE_ERROR(CPTError, Exception, "CPT error")
 
  GUM_MAKE_ERROR(ScheduleMultiDimError, Exception, "ScheduleMultiDim error")
 
  GUM_MAKE_ERROR(AbstractScheduleMultiDim,
                 ScheduleMultiDimError,
                 "The Schedule MultiDim Table is abstract")
 
  GUM_MAKE_ERROR(UnknownScheduleMultiDim,
                 ScheduleMultiDimError,
                 "The Schedule MultiDim Table is unknown")
 
  GUM_MAKE_ERROR(DuplicateScheduleMultiDim,
                 ScheduleMultiDimError,
                 "There exists another identical Schedule MultiDim Table")
 
  GUM_MAKE_ERROR(ScheduleOperationError, Exception, "ScheduleOperator error")
 
  GUM_MAKE_ERROR(UnknownScheduleOperation,
                 ScheduleOperationError,
                 "The Schedule operation is unknown")
 
  GUM_MAKE_ERROR(UnavailableScheduleOperation,
                 ScheduleOperationError,
                 "The Schedule operation is not available yet")
 
  GUM_MAKE_ERROR(UnexecutedScheduleOperation,
                 ScheduleOperationError,
                 "The Schedule operation has not been executed yet")
 
  GUM_MAKE_ERROR(IncompatibleEvidence,
                 Exception,
                 "Several evidence/CPT are incompatible together (proba=0)")
 
  GUM_MAKE_ERROR(FactoryError, Exception, "Factory error")
 
  GUM_MAKE_ERROR(FactoryInvalidState, FactoryError, "Invalid state error")
 
  GUM_MAKE_ERROR(TypeError, FactoryError, "Wrong type")
 
  GUM_MAKE_ERROR(WrongClassElement, FactoryError, "Wrong ClassElement")
 
  GUM_MAKE_ERROR(PRMTypeError, FactoryError, "Wrong subtype or subclass")
 
  GUM_MAKE_ERROR(LearningError, Exception, "Factory error")
 
  GUM_MAKE_ERROR(IncompatibleScorePrior, LearningError, "Incompatible (maybe implicit) priors")
 
  GUM_MAKE_ERROR(PossiblyIncompatibleScorePrior,
                 LearningError,
                 "Possible incompatibility between score and prior")
 
  GUM_MAKE_ERROR(DatabaseError, LearningError, "Database error")
 
  GUM_MAKE_ERROR(MissingVariableInDatabase, LearningError, "Missing variable name in database")
 
  GUM_MAKE_ERROR(MissingValueInDatabase, LearningError, "The database contains some missing values")
 
  GUM_MAKE_ERROR(UnknownLabelInDatabase, LearningError, "Unknown label found in database")
 
  class SyntaxError final: public IOError {
    protected:
    Size        noLine_;
    Size        noCol_;
    std::string filename_;
 
    public:
    SyntaxError(const std::string& aMsg,
                std::string        aFilename,
                Size               nol,
                Size               noc,
                const std::string& aType = "Syntax Error") :
        IOError(aMsg, aType), noLine_(nol), noCol_(noc), filename_(std::move(aFilename)) {
#  ifdef GUM_FOR_SWIG
      what_ = "[pyAgrum] " + msg_;
#  else    // GUM_FOR_SWIG
      std::ostringstream error_stream;
      error_stream << type_ << ":" << std::endl;
      error_stream << filename() << ":" << line() << "," << col() << " : " << msg_;
      what_ = error_stream.str();
#  endif   // GUM_FOR_SWIG
    }
 
    GUM_NODISCARD Size col() const { return noCol_; };
 
    GUM_NODISCARD Size line() const { return noLine_; };
 
    GUM_NODISCARD std::string filename() const { return filename_; };
  };
#endif   // DOXYGEN_SHOULD_SKIP_THIS
} /* namespace gum */
 
#endif /* GUM_EXCEPTIONS_H */