From 889a404ef51cda49c0b5f80bf7fde64f7b59c734 Mon Sep 17 00:00:00 2001 From: Jeremy Sowden Date: Thu, 14 Oct 2021 11:00:56 +0100 Subject: [PATCH] d/patches: add patch to fix FTBFS with g++-11 (closes: #984260) Dynamic exception specifications are obsolete and g++-11 throws errors when it find them. Upstream has removed them. This commit adds the upstream patch, rebased to apply against the source of the Debian pacakge. --- ...xception-specifications-from-clients.patch | 980 ++++++++++++++++++ debian/patches/series | 1 + 2 files changed, 981 insertions(+) create mode 100644 debian/patches/0014-Remove-dynamic-exception-specifications-from-clients.patch diff --git a/debian/patches/0014-Remove-dynamic-exception-specifications-from-clients.patch b/debian/patches/0014-Remove-dynamic-exception-specifications-from-clients.patch new file mode 100644 index 0000000..9ec6e35 --- /dev/null +++ b/debian/patches/0014-Remove-dynamic-exception-specifications-from-clients.patch @@ -0,0 +1,980 @@ +From fab323320d5b955ed034b2eea390a9bbb549e8e5 Mon Sep 17 00:00:00 2001 +From: Peter Klein +Date: Thu, 11 Jun 2020 02:32:13 +0000 +Subject: [PATCH] Remove dynamic exception specifications from + clients/nutclient.cpp + +These are invalid in c++17 and must be removed for compatibility with +modern compilers. +--- + clients/nutclient.cpp | 146 +++++++++++++++---------------- + clients/nutclient.h | 195 +++++++++++++++++++++--------------------- + 2 files changed, 167 insertions(+), 174 deletions(-) + +diff --git a/clients/nutclient.cpp b/clients/nutclient.cpp +index b597e0e1e6c1..f5f0b70ef297 100644 +--- a/clients/nutclient.cpp ++++ b/clients/nutclient.cpp +@@ -96,18 +96,18 @@ + public: + Socket(); + +- void connect(const std::string& host, int port)throw(nut::IOException); ++ void connect(const std::string& host, int port); + void disconnect(); + bool isConnected()const; + + void setTimeout(long timeout); + bool hasTimeout()const{return _tv.tv_sec>=0;} + +- size_t read(void* buf, size_t sz)throw(nut::IOException); +- size_t write(const void* buf, size_t sz)throw(nut::IOException); ++ size_t read(void* buf, size_t sz); ++ size_t write(const void* buf, size_t sz); + +- std::string read()throw(nut::IOException); +- void write(const std::string& str)throw(nut::IOException); ++ std::string read(); ++ void write(const std::string& str); + + + private: +@@ -129,7 +129,7 @@ + _tv.tv_sec = timeout; + } + +-void Socket::connect(const std::string& host, int port)throw(nut::IOException) ++void Socket::connect(const std::string& host, int port) + { + int sock_fd; + struct addrinfo hints, *res, *ai; +@@ -298,7 +298,7 @@ + return _sock!=INVALID_SOCKET; + } + +-size_t Socket::read(void* buf, size_t sz)throw(nut::IOException) ++size_t Socket::read(void* buf, size_t sz) + { + if(!isConnected()) + { +@@ -325,7 +325,7 @@ + return (size_t) res; + } + +-size_t Socket::write(const void* buf, size_t sz)throw(nut::IOException) ++size_t Socket::write(const void* buf, size_t sz) + { + if(!isConnected()) + { +@@ -352,7 +352,7 @@ + return (size_t) res; + } + +-std::string Socket::read()throw(nut::IOException) ++std::string Socket::read() + { + std::string res; + char buff[256]; +@@ -383,7 +383,7 @@ + } + } + +-void Socket::write(const std::string& str)throw(nut::IOException) ++void Socket::write(const std::string& str) + { + // write(str.c_str(), str.size()); + // write("\n", 1); +@@ -408,13 +408,13 @@ + { + } + +-bool Client::hasDevice(const std::string& dev)throw(NutException) ++bool Client::hasDevice(const std::string& dev) + { + std::set devs = getDeviceNames(); + return devs.find(dev) != devs.end(); + } + +-Device Client::getDevice(const std::string& name)throw(NutException) ++Device Client::getDevice(const std::string& name) + { + if(hasDevice(name)) + return Device(this, name); +@@ -422,7 +422,7 @@ + return Device(NULL, ""); + } + +-std::set Client::getDevices()throw(NutException) ++std::set Client::getDevices() + { + std::set res; + +@@ -435,13 +435,13 @@ + return res; + } + +-bool Client::hasDeviceVariable(const std::string& dev, const std::string& name)throw(NutException) ++bool Client::hasDeviceVariable(const std::string& dev, const std::string& name) + { + std::set names = getDeviceVariableNames(dev); + return names.find(name) != names.end(); + } + +-std::map > Client::getDeviceVariableValues(const std::string& dev)throw(NutException) ++std::map > Client::getDeviceVariableValues(const std::string& dev) + { + std::map > res; + +@@ -455,7 +455,7 @@ + return res; + } + +-bool Client::hasDeviceCommand(const std::string& dev, const std::string& name)throw(NutException) ++bool Client::hasDeviceCommand(const std::string& dev, const std::string& name) + { + std::set names = getDeviceCommandNames(dev); + return names.find(name) != names.end(); +@@ -477,7 +477,7 @@ + // Do not connect now + } + +-TcpClient::TcpClient(const std::string& host, int port)throw(IOException): ++TcpClient::TcpClient(const std::string& host, int port): + Client(), + _socket(new internal::Socket) + { +@@ -489,14 +489,14 @@ + delete _socket; + } + +-void TcpClient::connect(const std::string& host, int port)throw(IOException) ++void TcpClient::connect(const std::string& host, int port) + { + _host = host; + _port = port; + connect(); + } + +-void TcpClient::connect()throw(nut::IOException) ++void TcpClient::connect() + { + _socket->connect(_host, _port); + } +@@ -532,19 +532,18 @@ + } + + void TcpClient::authenticate(const std::string& user, const std::string& passwd) +- throw(NutException) + { + detectError(sendQuery("USERNAME " + user)); + detectError(sendQuery("PASSWORD " + passwd)); + } + +-void TcpClient::logout()throw(NutException) ++void TcpClient::logout() + { + detectError(sendQuery("LOGOUT")); + _socket->disconnect(); + } + +-Device TcpClient::getDevice(const std::string& name)throw(NutException) ++Device TcpClient::getDevice(const std::string& name) + { + try + { +@@ -560,7 +559,7 @@ + return Device(this, name); + } + +-std::set TcpClient::getDeviceNames()throw(NutException) ++std::set TcpClient::getDeviceNames() + { + std::set res; + +@@ -576,12 +575,12 @@ + return res; + } + +-std::string TcpClient::getDeviceDescription(const std::string& name)throw(NutException) ++std::string TcpClient::getDeviceDescription(const std::string& name) + { + return get("UPSDESC", name)[0]; + } + +-std::set TcpClient::getDeviceVariableNames(const std::string& dev)throw(NutException) ++std::set TcpClient::getDeviceVariableNames(const std::string& dev) + { + std::set set; + +@@ -594,7 +593,7 @@ + return set; + } + +-std::set TcpClient::getDeviceRWVariableNames(const std::string& dev)throw(NutException) ++std::set TcpClient::getDeviceRWVariableNames(const std::string& dev) + { + std::set set; + +@@ -607,17 +606,17 @@ + return set; + } + +-std::string TcpClient::getDeviceVariableDescription(const std::string& dev, const std::string& name)throw(NutException) ++std::string TcpClient::getDeviceVariableDescription(const std::string& dev, const std::string& name) + { + return get("DESC", dev + " " + name)[0]; + } + +-std::vector TcpClient::getDeviceVariableValue(const std::string& dev, const std::string& name)throw(NutException) ++std::vector TcpClient::getDeviceVariableValue(const std::string& dev, const std::string& name) + { + return get("VAR", dev + " " + name); + } + +-std::map > TcpClient::getDeviceVariableValues(const std::string& dev)throw(NutException) ++std::map > TcpClient::getDeviceVariableValues(const std::string& dev) + { + + std::map > map; +@@ -634,13 +633,13 @@ + return map; + } + +-void TcpClient::setDeviceVariable(const std::string& dev, const std::string& name, const std::string& value)throw(NutException) ++void TcpClient::setDeviceVariable(const std::string& dev, const std::string& name, const std::string& value) + { + std::string query = "SET VAR " + dev + " " + name + " " + escape(value); + detectError(sendQuery(query)); + } + +-void TcpClient::setDeviceVariable(const std::string& dev, const std::string& name, const std::vector& values)throw(NutException) ++void TcpClient::setDeviceVariable(const std::string& dev, const std::string& name, const std::vector& values) + { + std::string query = "SET VAR " + dev + " " + name; + for(size_t n=0; n TcpClient::getDeviceCommandNames(const std::string& dev)throw(NutException) ++std::set TcpClient::getDeviceCommandNames(const std::string& dev) + { + std::set cmds; + +@@ -663,32 +662,32 @@ + return cmds; + } + +-std::string TcpClient::getDeviceCommandDescription(const std::string& dev, const std::string& name)throw(NutException) ++std::string TcpClient::getDeviceCommandDescription(const std::string& dev, const std::string& name) + { + return get("CMDDESC", dev + " " + name)[0]; + } + +-void TcpClient::executeDeviceCommand(const std::string& dev, const std::string& name)throw(NutException) ++void TcpClient::executeDeviceCommand(const std::string& dev, const std::string& name) + { + detectError(sendQuery("INSTCMD " + dev + " " + name)); + } + +-void TcpClient::deviceLogin(const std::string& dev)throw(NutException) ++void TcpClient::deviceLogin(const std::string& dev) + { + detectError(sendQuery("LOGIN " + dev)); + } + +-void TcpClient::deviceMaster(const std::string& dev)throw(NutException) ++void TcpClient::deviceMaster(const std::string& dev) + { + detectError(sendQuery("MASTER " + dev)); + } + +-void TcpClient::deviceForcedShutdown(const std::string& dev)throw(NutException) ++void TcpClient::deviceForcedShutdown(const std::string& dev) + { + detectError(sendQuery("FSD " + dev)); + } + +-int TcpClient::deviceGetNumLogins(const std::string& dev)throw(NutException) ++int TcpClient::deviceGetNumLogins(const std::string& dev) + { + std::string num = get("NUMLOGINS", dev)[0]; + return atoi(num.c_str()); +@@ -696,7 +695,7 @@ + + + std::vector TcpClient::get +- (const std::string& subcmd, const std::string& params) throw(NutException) ++ (const std::string& subcmd, const std::string& params) + { + std::string req = subcmd; + if(!params.empty()) +@@ -714,7 +713,7 @@ + } + + std::vector > TcpClient::list +- (const std::string& subcmd, const std::string& params) throw(NutException) ++ (const std::string& subcmd, const std::string& params) + { + std::string req = subcmd; + if(!params.empty()) +@@ -748,13 +747,13 @@ + } + } + +-std::string TcpClient::sendQuery(const std::string& req)throw(IOException) ++std::string TcpClient::sendQuery(const std::string& req) + { + _socket->write(req); + return _socket->read(); + } + +-void TcpClient::detectError(const std::string& req)throw(NutException) ++void TcpClient::detectError(const std::string& req) + { + if(req.substr(0,3)=="ERR") + { +@@ -954,47 +953,44 @@ + return getName()getDeviceDescription(getName()); + } + + std::vector Device::getVariableValue(const std::string& name) +- throw(NutException) + { + return getClient()->getDeviceVariableValue(getName(), name); + } + + std::map > Device::getVariableValues() +- throw(NutException) + { + return getClient()->getDeviceVariableValues(getName()); + } + +-std::set Device::getVariableNames()throw(NutException) ++std::set Device::getVariableNames() + { + return getClient()->getDeviceVariableNames(getName()); + } + +-std::set Device::getRWVariableNames()throw(NutException) ++std::set Device::getRWVariableNames() + { + return getClient()->getDeviceRWVariableNames(getName()); + } + +-void Device::setVariable(const std::string& name, const std::string& value)throw(NutException) ++void Device::setVariable(const std::string& name, const std::string& value) + { + getClient()->setDeviceVariable(getName(), name, value); + } + + void Device::setVariable(const std::string& name, const std::vector& values) +- throw(NutException) + { + getClient()->setDeviceVariable(getName(), name, values); + } + + + +-Variable Device::getVariable(const std::string& name)throw(NutException) ++Variable Device::getVariable(const std::string& name) + { + if(getClient()->hasDeviceVariable(getName(), name)) + return Variable(this, name); +@@ -1002,7 +998,7 @@ + return Variable(NULL, ""); + } + +-std::set Device::getVariables()throw(NutException) ++std::set Device::getVariables() + { + std::set set; + +@@ -1015,7 +1011,7 @@ + return set; + } + +-std::set Device::getRWVariables()throw(NutException) ++std::set Device::getRWVariables() + { + std::set set; + +@@ -1028,12 +1024,12 @@ + return set; + } + +-std::set Device::getCommandNames()throw(NutException) ++std::set Device::getCommandNames() + { + return getClient()->getDeviceCommandNames(getName()); + } + +-std::set Device::getCommands()throw(NutException) ++std::set Device::getCommands() + { + std::set cmds; + +@@ -1046,7 +1042,7 @@ + return cmds; + } + +-Command Device::getCommand(const std::string& name)throw(NutException) ++Command Device::getCommand(const std::string& name) + { + if(getClient()->hasDeviceCommand(getName(), name)) + return Command(this, name); +@@ -1054,26 +1050,26 @@ + return Command(NULL, ""); + } + +-void Device::executeCommand(const std::string& name)throw(NutException) ++void Device::executeCommand(const std::string& name) + { + getClient()->executeDeviceCommand(getName(), name); + } + +-void Device::login()throw(NutException) ++void Device::login() + { + getClient()->deviceLogin(getName()); + } + +-void Device::master()throw(NutException) ++void Device::master() + { + getClient()->deviceMaster(getName()); + } + +-void Device::forcedShutdown()throw(NutException) ++void Device::forcedShutdown() + { + } + +-int Device::getNumLogins()throw(NutException) ++int Device::getNumLogins() + { + return getClient()->deviceGetNumLogins(getName()); + } +@@ -1141,22 +1137,22 @@ + return getName() Variable::getValue()throw(NutException) ++std::vector Variable::getValue() + { + return getDevice()->getClient()->getDeviceVariableValue(getDevice()->getName(), getName()); + } + +-std::string Variable::getDescription()throw(NutException) ++std::string Variable::getDescription() + { + return getDevice()->getClient()->getDeviceVariableDescription(getDevice()->getName(), getName()); + } + +-void Variable::setValue(const std::string& value)throw(NutException) ++void Variable::setValue(const std::string& value) + { + getDevice()->setVariable(getName(), value); + } + +-void Variable::setValues(const std::vector& values)throw(NutException) ++void Variable::setValues(const std::vector& values) + { + getDevice()->setVariable(getName(), values); + } +@@ -1225,12 +1221,12 @@ + return getName()getClient()->getDeviceCommandDescription(getDevice()->getName(), getName()); + } + +-void Command::execute()throw(NutException) ++void Command::execute() + { + getDevice()->executeCommand(getName()); + } +--- a/clients/nutclient.h ++++ b/clients/nutclient.h +@@ -51,9 +51,9 @@ + { + public: + NutException(const std::string& msg):_msg(msg){} +- virtual ~NutException() throw() {} +- virtual const char * what() const throw() {return this->_msg.c_str();} +- virtual std::string str() const throw() {return this->_msg;} ++ virtual ~NutException() {} ++ virtual const char * what() const noexcept {return this->_msg.c_str();} ++ virtual std::string str() const noexcept {return this->_msg;} + private: + std::string _msg; + }; +@@ -65,7 +65,7 @@ + { + public: + SystemException(); +- virtual ~SystemException() throw() {} ++ virtual ~SystemException() {} + private: + static std::string err(); + }; +@@ -78,7 +78,7 @@ + { + public: + IOException(const std::string& msg):NutException(msg){} +- virtual ~IOException() throw() {} ++ virtual ~IOException() {} + }; + + /** +@@ -88,7 +88,7 @@ + { + public: + UnknownHostException():IOException("Unknown host"){} +- virtual ~UnknownHostException() throw() {} ++ virtual ~UnknownHostException() {} + }; + + /** +@@ -98,7 +98,7 @@ + { + public: + NotConnectedException():IOException("Not connected"){} +- virtual ~NotConnectedException() throw() {} ++ virtual ~NotConnectedException() {} + }; + + /** +@@ -108,7 +108,7 @@ + { + public: + TimeoutException():IOException("Timeout"){} +- virtual ~TimeoutException() throw() {} ++ virtual ~TimeoutException() {} + }; + + /** +@@ -132,13 +132,13 @@ + * \todo Is his method is global to all connection protocol or is it specific to TCP ? + * \note Actually, authentication fails only if already set, not if bad values are sent. + */ +- virtual void authenticate(const std::string& user, const std::string& passwd)throw(NutException)=0; ++ virtual void authenticate(const std::string& user, const std::string& passwd)=0; + + /** + * Disconnect from the NUTD server. + * \todo Is his method is global to all connection protocol or is it specific to TCP ? + */ +- virtual void logout()throw(NutException)=0; ++ virtual void logout()=0; + + /** + * Device manipulations. +@@ -151,29 +151,29 @@ + * \param name Name of the device. + * \return The device. + */ +- virtual Device getDevice(const std::string& name)throw(NutException); ++ virtual Device getDevice(const std::string& name); + /** + * Retrieve the list of all devices supported by UPSD server. + * \return The set of supported devices. + */ +- virtual std::set getDevices()throw(NutException); ++ virtual std::set getDevices(); + /** + * Test if a device is supported by the NUTD server. + * \param dev Device name. + * \return true if supported, false otherwise. + */ +- virtual bool hasDevice(const std::string& dev)throw(NutException); ++ virtual bool hasDevice(const std::string& dev); + /** + * Retrieve names of devices supported by NUTD server. + * \return The set of names of supported devices. + */ +- virtual std::set getDeviceNames()throw(NutException)=0; ++ virtual std::set getDeviceNames()=0; + /** + * Retrieve the description of a device. + * \param name Device name. + * \return Device description. + */ +- virtual std::string getDeviceDescription(const std::string& name)throw(NutException)=0; ++ virtual std::string getDeviceDescription(const std::string& name)=0; + /** \} */ + + /** +@@ -186,54 +186,54 @@ + * \param dev Device name + * \return Variable names + */ +- virtual std::set getDeviceVariableNames(const std::string& dev)throw(NutException)=0; ++ virtual std::set getDeviceVariableNames(const std::string& dev)=0; + /** + * Retrieve names of read/write variables supported by a device. + * \param dev Device name + * \return RW variable names + */ +- virtual std::set getDeviceRWVariableNames(const std::string& dev)throw(NutException)=0; ++ virtual std::set getDeviceRWVariableNames(const std::string& dev)=0; + /** + * Test if a variable is supported by a device. + * \param dev Device name + * \param name Variable name + * \return true if the variable is supported. + */ +- virtual bool hasDeviceVariable(const std::string& dev, const std::string& name)throw(NutException); ++ virtual bool hasDeviceVariable(const std::string& dev, const std::string& name); + /** + * Retrieve the description of a variable. + * \param dev Device name + * \param name Variable name + * \return Variable description if provided. + */ +- virtual std::string getDeviceVariableDescription(const std::string& dev, const std::string& name)throw(NutException)=0; ++ virtual std::string getDeviceVariableDescription(const std::string& dev, const std::string& name)=0; + /** + * Retrieve values of a variable. + * \param dev Device name + * \param name Variable name + * \return Variable values (usually one) if available. + */ +- virtual std::vector getDeviceVariableValue(const std::string& dev, const std::string& name)throw(NutException)=0; ++ virtual std::vector getDeviceVariableValue(const std::string& dev, const std::string& name)=0; + /** + * Retrieve values of all variables of a device. + * \param dev Device name + * \return Variable values indexed by variable names. + */ +- virtual std::map > getDeviceVariableValues(const std::string& dev)throw(NutException); ++ virtual std::map > getDeviceVariableValues(const std::string& dev); + /** + * Intend to set the value of a variable. + * \param dev Device name + * \param name Variable name + * \param value Variable value + */ +- virtual void setDeviceVariable(const std::string& dev, const std::string& name, const std::string& value)throw(NutException)=0; ++ virtual void setDeviceVariable(const std::string& dev, const std::string& name, const std::string& value)=0; + /** + * Intend to set the value of a variable. + * \param dev Device name + * \param name Variable name + * \param value Variable value + */ +- virtual void setDeviceVariable(const std::string& dev, const std::string& name, const std::vector& values)throw(NutException)=0; ++ virtual void setDeviceVariable(const std::string& dev, const std::string& name, const std::vector& values)=0; + /** \} */ + + /** +@@ -246,27 +246,27 @@ + * \param dev Device name + * \return Command names + */ +- virtual std::set getDeviceCommandNames(const std::string& dev)throw(NutException)=0; ++ virtual std::set getDeviceCommandNames(const std::string& dev)=0; + /** + * Test if a command is supported by a device. + * \param dev Device name + * \param name Command name + * \return true if the command is supported. + */ +- virtual bool hasDeviceCommand(const std::string& dev, const std::string& name)throw(NutException); ++ virtual bool hasDeviceCommand(const std::string& dev, const std::string& name); + /** + * Retrieve the description of a command. + * \param dev Device name + * \param name Command name + * \return Command description if provided. + */ +- virtual std::string getDeviceCommandDescription(const std::string& dev, const std::string& name)throw(NutException)=0; ++ virtual std::string getDeviceCommandDescription(const std::string& dev, const std::string& name)=0; + /** + * Intend to execute a command. + * \param dev Device name + * \param name Command name + */ +- virtual void executeDeviceCommand(const std::string& dev, const std::string& name)throw(NutException)=0; ++ virtual void executeDeviceCommand(const std::string& dev, const std::string& name)=0; + /** \} */ + + /** +@@ -277,15 +277,15 @@ + * Log the current user (if authenticated) for a device. + * \param dev Device name. + */ +- virtual void deviceLogin(const std::string& dev)throw(NutException)=0; ++ virtual void deviceLogin(const std::string& dev)=0; + /** + * Retrieve the number of user longged in the specified device. + * \param dev Device name. + * \return Number of logged-in users. + */ +- virtual int deviceGetNumLogins(const std::string& dev)throw(NutException)=0; +- virtual void deviceMaster(const std::string& dev)throw(NutException)=0; +- virtual void deviceForcedShutdown(const std::string& dev)throw(NutException)=0; ++ virtual int deviceGetNumLogins(const std::string& dev)=0; ++ virtual void deviceMaster(const std::string& dev)=0; ++ virtual void deviceForcedShutdown(const std::string& dev)=0; + + protected: + Client(); +@@ -309,7 +309,7 @@ + * \param host Server host name. + * \param port Server port. + */ +- TcpClient(const std::string& host, int port = 3493)throw(nut::IOException); ++ TcpClient(const std::string& host, int port = 3493); + ~TcpClient(); + + /** +@@ -317,13 +317,13 @@ + * \param host Server host name. + * \param port Server port. + */ +- void connect(const std::string& host, int port = 3493)throw(nut::IOException); ++ void connect(const std::string& host, int port = 3493); + + /** + * Connect to the server. + * Host name and ports must have already set (usefull for reconnection). + */ +- void connect()throw(nut::IOException); ++ void connect(); + + /** + * Test if the connection is active. +@@ -358,39 +358,37 @@ + */ + int getPort()const; + +- virtual void authenticate(const std::string& user, const std::string& passwd)throw(NutException); +- virtual void logout()throw(NutException); ++ virtual void authenticate(const std::string& user, const std::string& passwd); ++ virtual void logout(); + +- virtual Device getDevice(const std::string& name)throw(NutException); +- virtual std::set getDeviceNames()throw(NutException); +- virtual std::string getDeviceDescription(const std::string& name)throw(NutException); +- +- virtual std::set getDeviceVariableNames(const std::string& dev)throw(NutException); +- virtual std::set getDeviceRWVariableNames(const std::string& dev)throw(NutException); +- virtual std::string getDeviceVariableDescription(const std::string& dev, const std::string& name)throw(NutException); +- virtual std::vector getDeviceVariableValue(const std::string& dev, const std::string& name)throw(NutException); +- virtual std::map > getDeviceVariableValues(const std::string& dev)throw(NutException); +- virtual void setDeviceVariable(const std::string& dev, const std::string& name, const std::string& value)throw(NutException); +- virtual void setDeviceVariable(const std::string& dev, const std::string& name, const std::vector& values)throw(NutException); +- +- virtual std::set getDeviceCommandNames(const std::string& dev)throw(NutException); +- virtual std::string getDeviceCommandDescription(const std::string& dev, const std::string& name)throw(NutException); +- virtual void executeDeviceCommand(const std::string& dev, const std::string& name)throw(NutException); +- +- virtual void deviceLogin(const std::string& dev)throw(NutException); +- virtual void deviceMaster(const std::string& dev)throw(NutException); +- virtual void deviceForcedShutdown(const std::string& dev)throw(NutException); +- virtual int deviceGetNumLogins(const std::string& dev)throw(NutException); ++ virtual Device getDevice(const std::string& name); ++ virtual std::set getDeviceNames(); ++ virtual std::string getDeviceDescription(const std::string& name); ++ ++ virtual std::set getDeviceVariableNames(const std::string& dev); ++ virtual std::set getDeviceRWVariableNames(const std::string& dev); ++ virtual std::string getDeviceVariableDescription(const std::string& dev, const std::string& name); ++ virtual std::vector getDeviceVariableValue(const std::string& dev, const std::string& name); ++ virtual std::map > getDeviceVariableValues(const std::string& dev); ++ virtual void setDeviceVariable(const std::string& dev, const std::string& name, const std::string& value); ++ virtual void setDeviceVariable(const std::string& dev, const std::string& name, const std::vector& values); ++ ++ virtual std::set getDeviceCommandNames(const std::string& dev); ++ virtual std::string getDeviceCommandDescription(const std::string& dev, const std::string& name); ++ virtual void executeDeviceCommand(const std::string& dev, const std::string& name); ++ ++ virtual void deviceLogin(const std::string& dev); ++ virtual void deviceMaster(const std::string& dev); ++ virtual void deviceForcedShutdown(const std::string& dev); ++ virtual int deviceGetNumLogins(const std::string& dev); + + protected: +- std::string sendQuery(const std::string& req)throw(nut::IOException); +- static void detectError(const std::string& req)throw(nut::NutException); ++ std::string sendQuery(const std::string& req); ++ static void detectError(const std::string& req); + +- std::vector get(const std::string& subcmd, const std::string& params = "") +- throw(nut::NutException); ++ std::vector get(const std::string& subcmd, const std::string& params = ""); + +- std::vector > list(const std::string& subcmd, const std::string& params = "") +- throw(nut::NutException); ++ std::vector > list(const std::string& subcmd, const std::string& params = ""); + + static std::vector explode(const std::string& str, size_t begin=0); + static std::string escape(const std::string& str); +@@ -455,92 +453,92 @@ + /** + * Retrieve the description of the devce if specified. + */ +- std::string getDescription()throw(NutException); ++ std::string getDescription(); + + /** + * Intend to retrieve the value of a variable of the device. + * \param name Name of the variable to get. + * \return Value of the variable, if available. + */ +- std::vector getVariableValue(const std::string& name)throw(NutException); ++ std::vector getVariableValue(const std::string& name); + /** + * Intend to retrieve values of all variables of the devices. + * \return Map of all variables values indexed by their names. + */ +- std::map > getVariableValues()throw(NutException); ++ std::map > getVariableValues(); + /** + * Retrieve all variables names supported by the device. + * \return Set of available variable names. + */ +- std::set getVariableNames()throw(NutException); ++ std::set getVariableNames(); + /** + * Retrieve all Read/Write variables names supported by the device. + * \return Set of available Read/Write variable names. + */ +- std::set getRWVariableNames()throw(NutException); ++ std::set getRWVariableNames(); + /** + * Intend to set the value of a variable of the device. + * \param name Variable name. + * \param value New variable value. + */ +- void setVariable(const std::string& name, const std::string& value)throw(NutException); ++ void setVariable(const std::string& name, const std::string& value); + /** + * Intend to set values of a variable of the device. + * \param name Variable name. + * \param value New variable values. + */ +- void setVariable(const std::string& name, const std::vector& values)throw(NutException); ++ void setVariable(const std::string& name, const std::vector& values); + + /** + * Retrieve a Variable object representing the specified variable. + * \param name Variable name. + * \return Variable object. + */ +- Variable getVariable(const std::string& name)throw(NutException); ++ Variable getVariable(const std::string& name); + /** + * Retrieve Variable objects representing all variables available for the device. + * \return Set of Variable objects. + */ +- std::set getVariables()throw(NutException); ++ std::set getVariables(); + /** + * Retrieve Variable objects representing all Read/Write variables available for the device. + * \return Set of Variable objects. + */ +- std::set getRWVariables()throw(NutException); ++ std::set getRWVariables(); + + /** + * Retrieve names of all commands supported by the device. + * \return Set of available command names. + */ +- std::set getCommandNames()throw(NutException); ++ std::set getCommandNames(); + /** + * Retrieve objects for all commands supported by the device. + * \return Set of available Command objects. + */ +- std::set getCommands()throw(NutException); ++ std::set getCommands(); + /** + * Retrieve an object representing a command of the device. + * \param name Command name. + * \return Command object. + */ +- Command getCommand(const std::string& name)throw(NutException); ++ Command getCommand(const std::string& name); + /** + * Intend to execute a command on the device. + * \param name Command name. + */ +- void executeCommand(const std::string& name)throw(NutException); ++ void executeCommand(const std::string& name); + + /** + * Login current client's user for the device. + */ +- void login()throw(NutException); +- void master()throw(NutException); +- void forcedShutdown()throw(NutException); ++ void login(); ++ void master(); ++ void forcedShutdown(); + /** + * Retrieve the number of logged user for the device. + * \return Number of users. + */ +- int getNumLogins()throw(NutException); ++ int getNumLogins(); + + protected: + Device(Client* client, const std::string& name); +@@ -603,23 +601,23 @@ + * Intend to retrieve variable value. + * \return Value of the variable. + */ +- std::vector getValue()throw(NutException); ++ std::vector getValue(); + /** + * Intend to retireve variable description. + * \return Variable description if provided. + */ +- std::string getDescription()throw(NutException); ++ std::string getDescription(); + + /** + * Intend to set a value to the variable. + * \param value New variable value. + */ +- void setValue(const std::string& value)throw(NutException); ++ void setValue(const std::string& value); + /** + * Intend to set (multiple) values to the variable. + * \param value New variable values. + */ +- void setValues(const std::vector& values)throw(NutException); ++ void setValues(const std::vector& values); + + protected: + Variable(Device* dev, const std::string& name); +@@ -683,13 +681,13 @@ + * Intend to retireve command description. + * \return Command description if provided. + */ +- std::string getDescription()throw(NutException); ++ std::string getDescription(); + + /** + * Intend to retrieve command description. + * \return Command description if provided. + */ +- void execute()throw(NutException); ++ void execute(); + + protected: + Command(Device* dev, const std::string& name); +-- +2.33.0 + diff --git a/debian/patches/series b/debian/patches/series index 50dc917..677ad2c 100644 --- a/debian/patches/series +++ b/debian/patches/series @@ -11,3 +11,4 @@ 0011-use-pkgconfig-module.patch 0012-add-AEG-PROTECT-NAS-support.patch 0013-fix-doc-build.patch +0014-Remove-dynamic-exception-specifications-from-clients.patch