$OpenBSD: patch-sqlplusint_exceptions_hh_in,v 1.1 2004/01/06 11:16:53 wilfried Exp $
--- sqlplusint/exceptions.hh.in.orig	2001-05-19 18:44:49.000000000 +0200
+++ sqlplusint/exceptions.hh.in	2004-01-04 23:39:41.000000000 +0100
@@ -10,66 +10,70 @@
                               // with --enable-exception flag.
 
 //: Exception thrown when a BadQuery is encountered
-class BadQuery : public exception {
+class BadQuery : public std::exception {
 public:
-  BadQuery(const string &er = "") : error(er) {}
-  const string error; //: The error message
-  virtual const char* what( void ) const { return error.c_str(); }
+  BadQuery(const std::string &er = "") : error(er) {}
+  ~BadQuery() throw () {}
+  const std::string error; //: The error message
+  virtual const char* what( void ) const throw () { return error.c_str(); }
 };
 
 //: Exception structure thrown when a bad conversion takes place
-class BadConversion : public exception {
-  const string _what;
+class BadConversion : public std::exception {
+  const std::string _what;
 public:
   const char*  type_name;  //:
-  const string data;       //:
+  const std::string data;       //:
   size_t       retrieved;  //:
   size_t       actual_size;//:
   BadConversion(const char* tn, const char* d, size_t r, size_t a)
-    : _what(string("Tried to convert \"") + string(d ? d : "") + "\" to a \"" + string(tn ? tn : "")),
+    : _what(std::string("Tried to convert \"") + std::string(d ? d : "") + "\" to a \"" + std::string(tn ? tn : "")),
       type_name(tn), data(d), retrieved(r), actual_size(a) {};
 
-  BadConversion(const string &wt, const char* tn, const char* d, size_t r, size_t a)
+  BadConversion(const std::string &wt, const char* tn, const char* d, size_t r, size_t a)
     : _what(wt), type_name(tn), data(d), retrieved(r), actual_size(a) {};
 
-  BadConversion(const string& wt = "")
+  BadConversion(const std::string& wt = "")
     : _what(wt), type_name("unknown"), data(""), retrieved(0), actual_size(0) {};
+  ~BadConversion() throw () {}
 
-  virtual const char* what( void ) const { return _what.c_str(); }
+  virtual const char* what( void ) const throw () { return _what.c_str(); }
 };
 
 //: Thrown when a *Null* value is trying to be converted into a type 
 //: it can't convert to.
-class BadNullConversion : public exception {
-  const string _what;
+class BadNullConversion : public std::exception {
+  const std::string _what;
 public:
-  BadNullConversion(const string &wt = "") : _what(wt) {}
-  virtual const char* what( void ) const { return _what.c_str(); }
+  BadNullConversion(const std::string &wt = "") : _what(wt) {}
+  ~BadNullConversion() throw () {}
+  virtual const char* what( void ) const throw () { return _what.c_str(); }
 };
 
 //: Exception thrown when not enough parameters are provided
 // Thrown when not enough parameters are provided for a 
 // template query.
-class SQLQueryNEParms : public exception {
-  const string _what;
+class SQLQueryNEParms : public std::exception {
+  const std::string _what;
 public:
-  SQLQueryNEParms(const char *c) : _what(string(c ? c : "")), error(c) {}
+  SQLQueryNEParms(const char *c) : _what(std::string(c ? c : "")), error(c) {}
+  ~SQLQueryNEParms() throw () {}
   const char* error; //:
-  virtual const char* what( void ) const { return _what.c_str(); }
+  virtual const char* what( void ) const throw () { return _what.c_str(); }
 };
 
 #else //origional, default exception style
 
 struct BadQuery {
-  BadQuery(string er) : error(er) {}
-  string error; //: The error message
+  BadQuery(std::string er) : error(er) {}
+  std::string error; //: The error message
 };
 
 
 //: Exception structure thrown when a bad conversion takes place
 struct BadConversion {
   const char*  type_name;  //:
-  const string data;       //:
+  const std::string data;  //:
   size_t       retrieved;  //:
   size_t       actual_size;//:
   BadConversion(const char* tn, const char* d, size_t r, size_t a) : type_name(tn), data(d), retrieved(r), actual_size(a) {};
