WT-11772: Resolve some Wunused-parameter warnings

These mostly come from the signature being copied from an interface. In
some cases, we cannot remove the warning, if a default value is being
assigned to it. These warnings will be resolved in the next commit.

Author: matthias

src/3rdparty/rapidxml/rapidxml_print.hpp

@@ -206,7 +206,7 @@ namespace rapidxml
 
         // Print attributes of the node
         template<class OutIt, class Ch>
-        inline OutIt print_attributes(OutIt out, const xml_node<Ch> *node, int flags)
+        inline OutIt print_attributes(OutIt out, const xml_node<Ch> *node, int)
         {
             for (xml_attribute<Ch> *attribute = node->first_attribute(); attribute; attribute = attribute->next_attribute())
             {

src/Wt/Auth/AbstractUserDatabase.C

@@ -52,25 +52,25 @@ AbstractUserDatabase::Transaction *AbstractUserDatabase::startTransaction()
   return nullptr;
 }
 
-AccountStatus AbstractUserDatabase::status(const User& user) const
+AccountStatus AbstractUserDatabase::status(WT_MAYBE_UNUSED const User& user) const
 {
   return AccountStatus::Normal;
 }
 
-void AbstractUserDatabase::setStatus(const User& user, AccountStatus status)
+void AbstractUserDatabase::setStatus(WT_MAYBE_UNUSED const User& user, WT_MAYBE_UNUSED AccountStatus status)
 {
   LOG_ERROR(Require("setStatus()").what());
 }
 
-PasswordHash AbstractUserDatabase::password(const User& user) const
+PasswordHash AbstractUserDatabase::password(WT_MAYBE_UNUSED const User& user) const
 {
   LOG_ERROR(Require("password()", PASSWORDS).what());
 
   return PasswordHash();
 }
 
-void AbstractUserDatabase::setPassword(const User& user,
-                                       const PasswordHash& password)
+void AbstractUserDatabase::setPassword(WT_MAYBE_UNUSED const User& user,
+                                       WT_MAYBE_UNUSED const PasswordHash& password)
 {
   LOG_ERROR(Require("setPassword()", PASSWORDS).what());
 }
@@ -90,245 +90,245 @@ User AbstractUserDatabase::registerNew()
   return User();
 }
 
-void AbstractUserDatabase::deleteUser(const User& user)
+void AbstractUserDatabase::deleteUser(WT_MAYBE_UNUSED const User& user)
 {
   LOG_ERROR(Require("deleteUser()", REGISTRATION).what());
 }
 
-std::string AbstractUserDatabase::email(const User& user) const
+std::string AbstractUserDatabase::email(WT_MAYBE_UNUSED const User& user) const
 {
   LOG_ERROR(Require("email()", EMAIL_VERIFICATION).what());
 
   return std::string();
 }
 
-bool AbstractUserDatabase::setEmail(const User& user,
-                                    const std::string& address)
+bool AbstractUserDatabase::setEmail(WT_MAYBE_UNUSED const User& user,
+                                    WT_MAYBE_UNUSED const std::string& address)
 {
   LOG_ERROR(Require("setEmail()", EMAIL_VERIFICATION).what());
   return false;
 }
 
-User AbstractUserDatabase::findWithEmail(const std::string& address) const
+User AbstractUserDatabase::findWithEmail(WT_MAYBE_UNUSED const std::string& address) const
 {
   LOG_ERROR(Require("findWithEmail()", EMAIL_VERIFICATION).what());
 
   return User();
 }
 
-std::string AbstractUserDatabase::unverifiedEmail(const User& user) const
+std::string AbstractUserDatabase::unverifiedEmail(WT_MAYBE_UNUSED const User& user) const
 {
   LOG_ERROR(Require("unverifiedEmail()", EMAIL_VERIFICATION).what());
 
   return std::string();
 }
 
-void AbstractUserDatabase::setUnverifiedEmail(const User& user,
-                                              const std::string& address)
+void AbstractUserDatabase::setUnverifiedEmail(WT_MAYBE_UNUSED const User& user,
+                                              WT_MAYBE_UNUSED const std::string& address)
 {
   LOG_ERROR(Require("setUnverifiedEmail()", EMAIL_VERIFICATION).what());
 }
 
-Token AbstractUserDatabase::emailToken(const User& user) const
+Token AbstractUserDatabase::emailToken(WT_MAYBE_UNUSED const User& user) const
 {
   LOG_ERROR(Require("emailToken()", EMAIL_VERIFICATION).what());
 
   return Token();
 }
 
-EmailTokenRole AbstractUserDatabase::emailTokenRole(const User& user)
+EmailTokenRole AbstractUserDatabase::emailTokenRole(WT_MAYBE_UNUSED const User& user)
   const
 {
   LOG_ERROR(Require("emailTokenRole()", EMAIL_VERIFICATION).what());
 
   return EmailTokenRole::VerifyEmail;
 }
 
-void AbstractUserDatabase::setEmailToken(const User& user, const Token& token,
-                                         EmailTokenRole role)
+void AbstractUserDatabase::setEmailToken(WT_MAYBE_UNUSED const User& user, WT_MAYBE_UNUSED const Token& token,
+                                         WT_MAYBE_UNUSED EmailTokenRole role)
 {
   LOG_ERROR(Require("setEmailToken()", EMAIL_VERIFICATION).what());
 }
 
-User AbstractUserDatabase::findWithEmailToken(const std::string& hash) const
+User AbstractUserDatabase::findWithEmailToken(WT_MAYBE_UNUSED const std::string& hash) const
 {
   LOG_ERROR(Require("findWithEmailToken()", EMAIL_VERIFICATION).what());
 
   return User();
 }
 
-void AbstractUserDatabase::addAuthToken(const User& user, const Token& token)
+void AbstractUserDatabase::addAuthToken(WT_MAYBE_UNUSED const User& user, WT_MAYBE_UNUSED const Token& token)
 {
   LOG_ERROR(Require("addAuthToken()", AUTH_TOKEN).what());
 }
 
-void AbstractUserDatabase::removeAuthToken(const User& user,
-                                           const std::string& hash)
+void AbstractUserDatabase::removeAuthToken(WT_MAYBE_UNUSED const User& user,
+                                           WT_MAYBE_UNUSED const std::string& hash)
 {
   LOG_ERROR(Require("removeAuthToken()", AUTH_TOKEN).what());
 }
 
-int AbstractUserDatabase::updateAuthToken(const User& user,
-                                          const std::string& hash,
-                                          const std::string& newHash)
+int AbstractUserDatabase::updateAuthToken(WT_MAYBE_UNUSED const User& user,
+                                          WT_MAYBE_UNUSED const std::string& hash,
+                                          WT_MAYBE_UNUSED const std::string& newHash)
 {
   LOG_WARN(Require("updateAuthToken()", AUTH_TOKEN).what());
 
   return -1;
 }
 
-User AbstractUserDatabase::findWithAuthToken(const std::string& hash) const
+User AbstractUserDatabase::findWithAuthToken(WT_MAYBE_UNUSED const std::string& hash) const
 {
   LOG_ERROR(Require("findWithAuthToken()", AUTH_TOKEN).what());
 
   return User();
 }
 
-int AbstractUserDatabase::failedLoginAttempts(const User& user) const
+int AbstractUserDatabase::failedLoginAttempts(WT_MAYBE_UNUSED const User& user) const
 {
   LOG_ERROR(Require("failedLoginAttempts()", THROTTLING).what());
 
   return 0;
 }
 
-void AbstractUserDatabase::setFailedLoginAttempts(const User& user, int count)
+void AbstractUserDatabase::setFailedLoginAttempts(WT_MAYBE_UNUSED const User& user, WT_MAYBE_UNUSED int count)
 {
   LOG_ERROR(Require("setFailedLoginAttempts()", THROTTLING).what());
 }
 
-WDateTime AbstractUserDatabase::lastLoginAttempt(const User& user) const
+WDateTime AbstractUserDatabase::lastLoginAttempt(WT_MAYBE_UNUSED const User& user) const
 {
   LOG_ERROR(Require("lastLoginAttempt()", THROTTLING).what());
 
   return WDateTime(WDate(1970, 1, 1));
 }
 
-void AbstractUserDatabase::setLastLoginAttempt(const User& user,
-                                               const WDateTime& t)
+void AbstractUserDatabase::setLastLoginAttempt(WT_MAYBE_UNUSED const User& user,
+                                               WT_MAYBE_UNUSED const WDateTime& timestamp)
 {
   LOG_ERROR(Require("setLastLoginAttempt()", THROTTLING).what());
 }
 
 // ...
-Auth::IssuedToken AbstractUserDatabase::idpTokenAdd(const std::string& value,
-                                                    const WDateTime& expirationTime,
-                                                    const std::string& purpose,
-                                                    const std::string& scope,
-                                                    const std::string& redirectUri,
-                                                    const User& user,
-                                                    const OAuthClient& authClient)
+Auth::IssuedToken AbstractUserDatabase::idpTokenAdd(WT_MAYBE_UNUSED const std::string& value,
+                                                    WT_MAYBE_UNUSED const WDateTime& expirationTime,
+                                                    WT_MAYBE_UNUSED const std::string& purpose,
+                                                    WT_MAYBE_UNUSED const std::string& scope,
+                                                    WT_MAYBE_UNUSED const std::string& redirectUri,
+                                                    WT_MAYBE_UNUSED const User& user,
+                                                    WT_MAYBE_UNUSED const OAuthClient& authClient)
 {
   LOG_ERROR(Require("idpTokenAdd()", IDP_SUPPORT).what());
   return IssuedToken();
 }
 
-void AbstractUserDatabase::idpTokenRemove(const IssuedToken& token)
+void AbstractUserDatabase::idpTokenRemove(WT_MAYBE_UNUSED const IssuedToken& token)
 {
   LOG_ERROR(Require("idpTokenRemove()", IDP_SUPPORT).what());
 }
 
 IssuedToken AbstractUserDatabase::idpTokenFindWithValue(
-  const std::string& purpose, const std::string& value) const
+  WT_MAYBE_UNUSED const std::string& purpose, WT_MAYBE_UNUSED const std::string& scope) const
 {
   LOG_ERROR(Require("idpTokenFindWithValue()", IDP_SUPPORT).what());
   return IssuedToken();
 }
 
-WDateTime AbstractUserDatabase::idpTokenExpirationTime(const IssuedToken &token) const
+WDateTime AbstractUserDatabase::idpTokenExpirationTime(WT_MAYBE_UNUSED const IssuedToken& token) const
 {
   LOG_ERROR(Require("idpTokenExpirationTime)", IDP_SUPPORT).what());
   return WDateTime(WDate(1970, 1, 1));
 }
 
-std::string AbstractUserDatabase::idpTokenValue(const IssuedToken &token) const
+std::string AbstractUserDatabase::idpTokenValue(WT_MAYBE_UNUSED const IssuedToken& token) const
 {
   LOG_ERROR(Require("idpTokenValue()", IDP_SUPPORT).what());
   return std::string();
 }
 
-std::string AbstractUserDatabase::idpTokenPurpose(const IssuedToken &token) const
+std::string AbstractUserDatabase::idpTokenPurpose(WT_MAYBE_UNUSED const IssuedToken& token) const
 {
   LOG_ERROR(Require("idpTokenPurpose()", IDP_SUPPORT).what());
   return std::string();
 }
 
-std::string AbstractUserDatabase::idpTokenScope(const IssuedToken &token) const
+std::string AbstractUserDatabase::idpTokenScope(WT_MAYBE_UNUSED const IssuedToken& token) const
 {
   LOG_ERROR(Require("idpTokenScope()", IDP_SUPPORT).what());
   return std::string();
 }
 
-std::string AbstractUserDatabase::idpTokenRedirectUri(const IssuedToken &token) const
+std::string AbstractUserDatabase::idpTokenRedirectUri(WT_MAYBE_UNUSED const IssuedToken& token) const
 {
   LOG_ERROR(Require("idpTokenRedirectUri()", IDP_SUPPORT).what());
   return std::string();
 }
 
-User AbstractUserDatabase::idpTokenUser(const IssuedToken &token) const
+User AbstractUserDatabase::idpTokenUser(WT_MAYBE_UNUSED const IssuedToken& token) const
 {
   LOG_ERROR(Require("idpTokenUser()", IDP_SUPPORT).what());
   return User();
 }
 
-OAuthClient AbstractUserDatabase::idpTokenOAuthClient(const IssuedToken &token) const
+OAuthClient AbstractUserDatabase::idpTokenOAuthClient(WT_MAYBE_UNUSED const IssuedToken& token) const
 {
   LOG_ERROR(Require("idpTokenOAuthClient()", IDP_SUPPORT).what());
   return OAuthClient();
 }
 
-Json::Value AbstractUserDatabase::idpJsonClaim(const User& user, const std::string& claim) const
+Json::Value AbstractUserDatabase::idpJsonClaim(WT_MAYBE_UNUSED const User& user, WT_MAYBE_UNUSED const std::string& claim) const
 {
   LOG_ERROR(Require("idpClaim()", IDP_SUPPORT).what());
   return Wt::Json::Value::Null; // full namespace for cnor
 }
 
-OAuthClient AbstractUserDatabase::idpClientFindWithId(const std::string &clientId) const
+OAuthClient AbstractUserDatabase::idpClientFindWithId(WT_MAYBE_UNUSED const std::string& clientId) const
 {
   LOG_ERROR(Require("idpClientFindWithId()", IDP_SUPPORT).what());
   return OAuthClient();
 }
 
-std::string AbstractUserDatabase::idpClientSecret(const OAuthClient &client) const
+std::string AbstractUserDatabase::idpClientSecret(WT_MAYBE_UNUSED const OAuthClient& client) const
 {
   LOG_ERROR(Require("idpClientSecret()", IDP_SUPPORT).what());
   return std::string();
 }
 
-bool AbstractUserDatabase::idpVerifySecret(const OAuthClient &client, const std::string& secret) const
+bool AbstractUserDatabase::idpVerifySecret(WT_MAYBE_UNUSED const OAuthClient& client, WT_MAYBE_UNUSED const std::string& secret) const
 {
   LOG_ERROR(Require("idpVerifySecret()", IDP_SUPPORT).what());
   return false;
 }
 
-std::set<std::string> AbstractUserDatabase::idpClientRedirectUris(const OAuthClient &client) const
+std::set<std::string> AbstractUserDatabase::idpClientRedirectUris(WT_MAYBE_UNUSED const OAuthClient& client) const
 {
   LOG_ERROR(Require("idpClientRedirectUris()", IDP_SUPPORT).what());
   return std::set<std::string>();
 }
 
-std::string AbstractUserDatabase::idpClientId(const OAuthClient &client) const
+std::string AbstractUserDatabase::idpClientId(WT_MAYBE_UNUSED const OAuthClient& client) const
 {
   LOG_ERROR(Require("idpClientId()", IDP_SUPPORT).what());
   return std::string();
 }
 
-bool AbstractUserDatabase::idpClientConfidential(const OAuthClient &client) const
+bool AbstractUserDatabase::idpClientConfidential(WT_MAYBE_UNUSED const OAuthClient& client) const
 {
   LOG_ERROR(Require("idpClientConfidential()", IDP_SUPPORT).what());
   return false;
 }
 
-ClientSecretMethod AbstractUserDatabase::idpClientAuthMethod(const OAuthClient &client) const
+ClientSecretMethod AbstractUserDatabase::idpClientAuthMethod(WT_MAYBE_UNUSED const OAuthClient& client) const
 {
   LOG_ERROR(Require("idpClientAuthMethod()", IDP_SUPPORT).what());
   return HttpAuthorizationBasic;
 }
 
-OAuthClient AbstractUserDatabase::idpClientAdd(const std::string& clientId,
-    bool confidential,
-    const std::set<std::string> &redirectUris,
-    ClientSecretMethod authMethod,
-    const std::string &secret)
+OAuthClient AbstractUserDatabase::idpClientAdd(WT_MAYBE_UNUSED const std::string& clientId,
+    WT_MAYBE_UNUSED bool confidential,
+    WT_MAYBE_UNUSED const std::set<std::string>& redirectUris,
+    WT_MAYBE_UNUSED ClientSecretMethod authMethod,
+    WT_MAYBE_UNUSED const std::string& secret)
 {
   LOG_ERROR(Require("idpTokenAdd()", IDP_SUPPORT).what());
   return OAuthClient();

src/Wt/Auth/AuthWidget.C

@@ -106,7 +106,7 @@ void AuthWidget::onPathChange(const std::string& path)
   handleRegistrationPath(path);
 }
 
-bool AuthWidget::handleRegistrationPath(const std::string& path)
+bool AuthWidget::handleRegistrationPath(WT_MAYBE_UNUSED const std::string& path)
 {
   if (!basePath_.empty()) {
     WApplication *app = WApplication::instance();

src/Wt/Auth/HashFunction.C

@@ -112,7 +112,7 @@ std::string BCryptHashFunction::compute(const std::string& msg,
 }
 
 bool BCryptHashFunction::verify(const std::string& msg,
-                                const std::string& salt,
+                                WT_MAYBE_UNUSED const std::string& salt,
                                 const std::string& hash) const
 {
   char result[64];

src/Wt/Auth/OAuthService.C

@@ -304,7 +304,7 @@ void OAuthProcess::connectStartAuthenticate(EventSignalBase &s)
 }
 #endif
 
-void OAuthProcess::getIdentity(const OAuthAccessToken& token)
+void OAuthProcess::getIdentity(WT_MAYBE_UNUSED const OAuthAccessToken& token)
 {
   throw WException("OAuth::Process::Identity(): not specialized");
 }

src/Wt/Auth/OAuthTokenEndpoint.C

@@ -214,7 +214,7 @@ void OAuthTokenEndpoint::handleRequest(const Http::Request &request, Http::Respo
 }
 
 const std::string OAuthTokenEndpoint::idTokenPayload(const std::string &clientId,
-                                                     const std::string &scope,
+                                                     WT_MAYBE_UNUSED const std::string& scope,
                                                      const User &user)
 {
   Json::Object root;

src/Wt/Auth/RegistrationWidget.C

@@ -278,7 +278,7 @@ void RegistrationWidget::doRegister()
     t->commit();
 }
 
-void RegistrationWidget::registerUserDetails(User& user)
+void RegistrationWidget::registerUserDetails(WT_MAYBE_UNUSED User& user)
 { }
 
 void RegistrationWidget::close()