X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/1361e008419329de33e4c92a6ad96621d40a9c40..3dd753cd9e46d794e00629d03183250aec4a17e4:/include/simgrid/Exception.hpp

diff --git a/include/simgrid/Exception.hpp b/include/simgrid/Exception.hpp
index e1798d910e..304295ae96 100644
--- a/include/simgrid/Exception.hpp
+++ b/include/simgrid/Exception.hpp
@@ -1,4 +1,4 @@
-/* Copyright (c) 2018-2020. The SimGrid Team. All rights reserved.          */
+/* Copyright (c) 2018-2022. The SimGrid Team. All rights reserved.          */
 
 /* This program is free software; you can redistribute it and/or modify it
  * under the terms of the license (GNU LGPL) which comes with this package. */
@@ -81,8 +81,8 @@ public:
 /** Ancestor class of all SimGrid exception */
 class Exception : public std::runtime_error {
 public:
-  Exception(const simgrid::xbt::ThrowPoint& throwpoint, const std::string& message)
-      : std::runtime_error(message), throwpoint_(throwpoint)
+  Exception(simgrid::xbt::ThrowPoint&& throwpoint, const std::string& message)
+      : std::runtime_error(message), throwpoint_(std::move(throwpoint))
   {
   }
   Exception(const Exception&)     = default;
@@ -92,77 +92,68 @@ public:
   /** Return the information about where the exception was thrown */
   xbt::ThrowPoint const& throw_point() const { return throwpoint_; }
 
+  /** Allow to carry a value (used by testany/waitany) */
+  ssize_t get_value() const { return value_; }
+  void set_value(ssize_t value) { value_ = value; }
+
   std::string resolve_backtrace() const { return throwpoint_.backtrace_.resolve(); }
 
-  /** Allow to carry a value (used by waitall/waitany) */
-  int value = 0;
+  XBT_ATTRIB_NORETURN virtual void rethrow_nested(simgrid::xbt::ThrowPoint&& throwpoint,
+                                                  const std::string& message) const
+  {
+    std::throw_with_nested(Exception(std::move(throwpoint), message));
+  }
 
 private:
   xbt::ThrowPoint throwpoint_;
+  ssize_t value_ = 0;
 };
 
-/** Exception raised when a timeout elapsed */
-class TimeoutException : public Exception {
-public:
-  using Exception::Exception;
-  ~TimeoutException() override;
-};
+#define DECLARE_SIMGRID_EXCEPTION(AnyException, ...)                                                                   \
+  class AnyException : public Exception {                                                                              \
+  public:                                                                                                              \
+    using Exception::Exception;                                                                                        \
+    __VA_ARGS__                                                                                                        \
+    ~AnyException() override;                                                                                          \
+    XBT_ATTRIB_NORETURN void rethrow_nested(simgrid::xbt::ThrowPoint&& throwpoint,                                     \
+                                            const std::string& message) const override                                 \
+    {                                                                                                                  \
+      std::throw_with_nested(AnyException(std::move(throwpoint), message));                                            \
+    }                                                                                                                  \
+  }
 
-XBT_ATTRIB_DEPRECATED_v328("Please use simgrid::TimeoutException") typedef TimeoutException TimeoutError;
+/** Exception raised when a timeout elapsed */
+DECLARE_SIMGRID_EXCEPTION(TimeoutException);
 
 /** Exception raised when a host fails */
-class HostFailureException : public Exception {
-public:
-  using Exception::Exception;
-  ~HostFailureException() override;
-};
+DECLARE_SIMGRID_EXCEPTION(HostFailureException);
 
 /** Exception raised when a communication fails because of the network or because of the remote host */
-class NetworkFailureException : public Exception {
-public:
-  using Exception::Exception;
-  ~NetworkFailureException() override;
-};
+DECLARE_SIMGRID_EXCEPTION(NetworkFailureException);
 
 /** Exception raised when a storage fails */
-class StorageFailureException : public Exception {
-public:
-  using Exception::Exception;
-  ~StorageFailureException() override;
-};
+DECLARE_SIMGRID_EXCEPTION(StorageFailureException);
 
 /** Exception raised when a VM fails */
-class VmFailureException : public Exception {
-public:
-  using Exception::Exception;
-  ~VmFailureException() override;
-};
+DECLARE_SIMGRID_EXCEPTION(VmFailureException);
 
 /** Exception raised when something got canceled before completion */
-class CancelException : public Exception {
-public:
-  using Exception::Exception;
-  ~CancelException() override;
-};
+DECLARE_SIMGRID_EXCEPTION(CancelException);
 
 /** Exception raised when something is going wrong during the simulation tracing */
-class TracingError : public Exception {
-public:
-  using Exception::Exception;
-  ~TracingError() override;
-};
+DECLARE_SIMGRID_EXCEPTION(TracingError);
 
 /** Exception raised when something is going wrong during the parsing of XML files */
-class ParseError : public Exception {
-public:
-  ParseError(const std::string& file, int line, const std::string& msg)
-      : Exception(XBT_THROW_POINT, xbt::string_printf("Parse error at %s:%d: %s", file.c_str(), line, msg.c_str()))
-  {
+#define PARSE_ERROR_CONSTRUCTOR                                                                                        \
+  ParseError(const std::string& file, int line, const std::string& msg)                                                \
+      : Exception(XBT_THROW_POINT, xbt::string_printf("Parse error at %s:%d: %s", file.c_str(), line, msg.c_str()))    \
+  {                                                                                                                    \
   }
-  ParseError(const ParseError&)     = default;
-  ParseError(ParseError&&) noexcept = default;
-  ~ParseError() override;
-};
+
+DECLARE_SIMGRID_EXCEPTION(ParseError, PARSE_ERROR_CONSTRUCTOR);
+#undef PARSE_ERROR_CONSTRUCTOR
+
+#undef DECLARE_SIMGRID_EXCEPTION
 
 class XBT_PUBLIC ForcefulKillException {
   /** @brief Exception launched to kill an actor; DO NOT BLOCK IT!
@@ -203,7 +194,4 @@ private:
 };
 
 } // namespace simgrid
-
-XBT_ATTRIB_DEPRECATED_v328("Please use simgrid::Exception") typedef simgrid::Exception xbt_ex;
-
 #endif