exceptions.h

Go to the documentation of this file.

#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 <agrum/tools/core/types.h>

#define GUM_ERROR_IN_EXPR(type, msg) throw(type(msg))

#ifdef GUM_FOR_SWIG
#  define GUM_ERROR(type, msg)         \
    {                                  \
      std::ostringstream __error__str; \
      __error__str << msg;             \
      throw(type(__error__str.str())); \
    }
#  define GUM_SHOWERROR(e)                                                      \
    {                                                                           \
      std::cout << std::endl                                                    \
                << (e).errorType() << " : " << (e).errorContent() << std::endl; \
    }
#else
#  ifndef GUM_DEBUG_MODE
#    define GUM_ERROR(type, msg)                                    \
      {                                                             \
        std::ostringstream __error__str;                            \
        __error__str << __FILE__ << ":" << __LINE__ << ": " << msg; \
        throw(type(__error__str.str()));                            \
      }
#    define GUM_SHOWERROR(e)                                               \
      {                                                                    \
        std::cout << std::endl                                             \
                  << __FILE__ << ":" << __LINE__ << " " << (e).errorType() \
                  << " from " << std::endl                                 \
                  << (e).errorContent() << std::endl;                      \
      }
#  else // GUM_FOR_SWIG
#    define GUM_ERROR(type, msg)                                    \
      {                                                             \
        std::ostringstream __error__str;                            \
        __error__str << msg;                                        \
        throw(type(gum::__createMsg(                                \
           __FILE__, __FUNCTION__, __LINE__, __error__str.str()))); \
      }
#    define GUM_SHOWERROR(e)                                               \
      {                                                                    \
        std::cout << std::endl                                             \
                  << __FILE__ << ":" << __LINE__ << " " << (e).errorType() \
                  << " from " << std::endl                                 \
                  << (e).errorContent() << std::endl;                      \
        std::cout << (e).errorCallStack() << std::endl;                    \
      }
#  endif   // GUM_DEBUG_MODE
#endif     //  GUM_FOR_SWIG

#define GUM_MAKE_ERROR(TYPE, SUPERCLASS, MSG)                                    \
  class TYPE: public SUPERCLASS {                                                \
    public:                                                                      \
    TYPE(std::string aMsg, std::string aType = MSG) : SUPERCLASS(aMsg, aType){}; \
    TYPE(const TYPE& src) : SUPERCLASS(src){};                                   \
  };

#define GUM_SYNTAX_ERROR(msg, line, column)                    \
  {                                                            \
    std::ostringstream __error__str;                           \
    __error__str << msg;                                       \
    throw(gum::SyntaxError(__error__str.str(), line, column)); \
  }

namespace gum {

  class Exception {
    protected:
    std::string _msg;
    std::string _type;
    std::string _callstack;

    public:
    // ====================================================================
    // ====================================================================
    Exception(const std::string aMsg = "",
              const std::string aType = "Generic error");

    Exception(const Exception& e);

    ~Exception() {}

#ifdef GUM_FOR_SWIG
    const std::string what() const { return "[pyAgrum] " + _type + ": " + _msg; }
#else // GUM_FOR_SWIG
    const std::string what() const { return _type + " : " + _msg; }
#endif  // GUM_FOR_SWIG

    const std::string errorContent() const { return _msg; }

    const std::string errorType() const { return _type; }

    const std::string errorCallStack() const { return _callstack; }
  };

  class IdError;

  class FatalError;

  class UndefinedIteratorValue;

  class UndefinedIteratorKey;

  class NullElement;

  class UndefinedElement;

  class SizeError;

  class EmptySet;

  class InvalidArgumentsNumber;

  class InvalidArgument;

  class IOError;

  class FormatNotFound;

  class OperationNotAllowed;

  class NotFound;

  class ReferenceError;

  class OutOfBounds;

  class OutOfLowerBound;

  class OutOfUpperBound;

  class DuplicateElement;

  class DuplicateLabel;


  class GraphError;

  class NoNeighbour;

  class NoParent;

  class NoChild;

  class InvalidEdge;

  class InvalidArc;

  class InvalidNode;

  class EmptyBSTree;

  class DefaultInLabel;

  class InvalidDirectedCycle;


  class CPTError;

  class CPTNoSumTo1;

  class IncompatibleEvidence;

  class FactoryError;

  class FactoryInvalidState;

  class WrongType;

  class WrongClassElement;

  class TypeError;

  class LearningError;

  class IncompatibleScoreApriori;

  class PossiblyIncompatibleScoreApriori;

  class DatabaseError;

  class MissingVariableInDatabase;

  class UnknownLabelInDatabase;

  class MissingValueInDatabase;


  class SyntaxError;

  class NotImplementedYet;


#ifndef DOXYGEN_SHOULD_SKIP_THIS
  const std::string __createMsg(const std::string& filename,
                                const std::string& function,
                                const int          line,
                                const std::string& msg);
  GUM_MAKE_ERROR(IdError, Exception, "ID error")
  GUM_MAKE_ERROR(FatalError, Exception, "Fatal error")
  GUM_MAKE_ERROR(NotImplementedYet, Exception, "Not implemented yet")
  GUM_MAKE_ERROR(UndefinedIteratorValue, Exception, "Undefined iterator")
  GUM_MAKE_ERROR(UndefinedIteratorKey, Exception, "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(EmptySet, Exception, "Empty set")
  GUM_MAKE_ERROR(InvalidArgumentsNumber, Exception, "Invalid argument number")
  GUM_MAKE_ERROR(InvalidArgument, Exception, "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(ReferenceError, Exception, "Reference error")
  GUM_MAKE_ERROR(OutOfBounds, ReferenceError, "Out of bound error")
  GUM_MAKE_ERROR(OutOfLowerBound, OutOfBounds, "Out of lower bound error")
  GUM_MAKE_ERROR(OutOfUpperBound, OutOfBounds, "Out of upper bound error")
  GUM_MAKE_ERROR(DuplicateElement, ReferenceError, "Duplicate element")
  GUM_MAKE_ERROR(DuplicateLabel, ReferenceError, "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, "Edge invalid")
  GUM_MAKE_ERROR(InvalidArc, GraphError, "Arc invalid")
  GUM_MAKE_ERROR(InvalidNode, GraphError, "Node invalid")
  GUM_MAKE_ERROR(EmptyBSTree, GraphError, "Empty binary search tree")
  GUM_MAKE_ERROR(DefaultInLabel, GraphError, "Error on label")
  GUM_MAKE_ERROR(InvalidDirectedCycle, GraphError, "Directed cycle detected")
  GUM_MAKE_ERROR(CPTError, Exception, "CPT error")
  GUM_MAKE_ERROR(CPTNoSumTo1, CPTError, "CPT does not sum to 1")
  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(WrongType, FactoryError, "wrong type for this operation")
  GUM_MAKE_ERROR(WrongClassElement, FactoryError, "Wrong ClassElement")
  GUM_MAKE_ERROR(TypeError, FactoryError, "Wrong subtype or subclass")
  GUM_MAKE_ERROR(LearningError, Exception, "Factory error")
  GUM_MAKE_ERROR(IncompatibleScoreApriori,
                 LearningError,
                 "Incompatbile (maybe implicit) priors")
  GUM_MAKE_ERROR(PossiblyIncompatibleScoreApriori,
                 LearningError,
                 "Possible incompatibilty 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: public IOError {
    protected:
    Size _noLine;
    Size _noCol;

    public:
    SyntaxError(const std::string& aMsg,
                Size               nol,
                Size               noc,
                std::string        aType = "Syntax Error") :
        IOError(aMsg, aType),
        _noLine(nol), _noCol(noc){

                      };

    Size col() const { return _noCol; };
    Size line() const { return _noLine; };
  };
#endif   // DOXYGEN_SHOULD_SKIP_THIS
} /* namespace gum */

#endif /* GUM_EXCEPTIONS_H */