Switch to custom exceptions

Author: eisenhauer

source/adios2/common/ADIOSTypes.h

@@ -359,6 +359,34 @@ std::string ToString(const Dims &dims);
 std::string ToString(const Box<Dims> &box);
 std::string ToString(const MemorySpace value);
 
+// Derived exception class for specific errors
+class PluginLoadFailure : public std::runtime_error
+{
+public:
+    PluginLoadFailure(const std::string &msg, const std::string &Library, const std::string &Name)
+    : runtime_error(msg), m_PluginLibrary(Library), m_PluginName(Name)
+    {
+    }
+
+    std::string m_PluginLibrary;
+    std::string m_PluginName;
+
+private:
+};
+
+class MissingOperatorFailure : public std::invalid_argument
+{
+public:
+    MissingOperatorFailure(const std::string &msg, const std::string &Operator)
+    : invalid_argument(msg), m_Operator(Operator)
+    {
+    }
+
+    std::string m_Operator;
+
+private:
+};
+
 /** UserOptions holds all user options from ~/.config/adios2/adios2.yaml */
 struct UserOptions
 {

source/adios2/operator/OperatorFactory.cpp

@@ -182,9 +182,11 @@ std::shared_ptr<Operator> MakeOperator(const std::string &type, const Params &pa
 
     if (ret == nullptr)
     {
-        helper::Throw<std::invalid_argument>("Operator", "OperatorFactory", "MakeOperator",
-                                             "ADIOS2 didn't compile with " + typeLowerCase +
-                                                 " library, operator not added");
+        auto m = MakeMessage("Operator", "OperatorFactory", "MakeOperator",
+                             "ADIOS2 didn't compile with " + typeLowerCase +
+                                 " library, operator not added",
+                             -1, helper::LogMode::EXCEPTION);
+        throw MissingOperatorFailure(m, typeLowerCase);
     }
 
     return ret;

source/adios2/operator/plugin/PluginOperator.cpp

@@ -82,9 +82,11 @@ void PluginOperator::PluginInit(const std::string &pluginName, const std::string
     }
     catch (...)
     {
-        helper::Throw<std::runtime_error>("Plugins", "PluginOperator", "PluginInit",
-                                          "Failed to load library \"" + pluginLibrary +
-                                              "\" looking for plugin \"" + pluginName + "\"");
+        auto m = MakeMessage("Plugins", "PluginOperator", "PluginInit",
+                             "Failed to load library " + m_PluginLibrary + " looking for plugin " +
+                                 m_PluginName,
+                             -1, helper::LogMode::EXCEPTION);
+        throw PluginLoadFailure(m, pluginLibrary, pluginName);
     }
     m_Impl->m_HandleCreate = pluginManager.GetOperatorCreateFun(pluginName);
     m_Impl->m_HandleDestroy = pluginManager.GetOperatorDestroyFun(pluginName);

source/utils/bpls/bpls.cpp

@@ -1026,27 +1026,15 @@ int doList_operators(core::Engine *fp, core::IO *io)
                         OpStrings.insert(op->m_TypeString);
                     }
                 }
-                catch (std::invalid_argument const &ex)
+                catch (MissingOperatorFailure const &ex)
                 {
-                    // if we didn't compile with the operator, the above with throw.  Parse the text
-                    std::string text = ex.what();
-                    size_t start = text.find("compile with ") + 13;
-                    size_t end = text.substr(start).find(' ');
-                    std::string op = text.substr(start, end);
-                    OpStrings.insert(op);
+                    // we didn't compile with the operator used
+                    OpStrings.insert(ex.m_Operator);
                 }
-                catch (std::runtime_error const &ex)
+                catch (PluginLoadFailure const &ex)
                 {
-                    // plugin operator we didn't find  Parse the text
-                    std::string text = ex.what();
-                    size_t libstart = text.find("library \"") + 9;
-                    size_t libend = text.substr(libstart).find('"');
-                    std::string lib = text.substr(libstart, libend);
-                    std::string rem = text.substr(libstart + libend + 1);
-                    size_t opstart = rem.find('"') + 1;
-                    size_t opend = rem.substr(opstart).find('"');
-                    std::string op = rem.substr(opstart, opend);
-                    OpStrings.insert(lib + "(" + op + ")");
+                    // plugin operator we didn't find
+                    OpStrings.insert(ex.m_PluginLibrary + "(" + ex.m_PluginName + ")");
                 }
             }
         }