Fix code in response to clang warnings.

Removes some unused private members and restructure switch statement to handle all cases. Test-Information: Fixed code does not emit the clang warnings anymore. Change-Id: I06a9036b307014e2f882e3cee45a6881b24c3f70
author: Tobias Markmann <tm@ayena.de> 2014-10-23 12:24:36 (GMT)
committer: Tobias Markmann <tm@ayena.de> 2014-10-23 12:24:36 (GMT)
commit: fa67c2b239d9c7fc508205ea17724322011194f4 (patch)
tree: 33c09d0a38bbf2a61b9f0dbadc048d7665542972
parent: 052190912463d8ea36979fd5a5e9a298588dce4f (diff)
download: swift-contrib-fa67c2b239d9c7fc508205ea17724322011194f4.zip
swift-contrib-fa67c2b239d9c7fc508205ea17724322011194f4.tar.bz2
6 files changed, 27 insertions, 27 deletions
diff --git a/Sluift/ElementConvertors/StatusShowConvertor.cpp b/Sluift/ElementConvertors/StatusShowConvertor.cpp
index d8e24ab..27876ff 100644
--- a/Sluift/ElementConvertors/StatusShowConvertor.cpp
+++ b/Sluift/ElementConvertors/StatusShowConvertor.cpp
@@ -1,74 +1,74 @@
 /*
  * Copyright (c) 2014 Remko Tronçon
  * Licensed under the GNU General Public License.
  * See the COPYING file for more information.
  */
 
 #include <Sluift/ElementConvertors/StatusShowConvertor.h>
 
 #include <lua.hpp>
 #include <boost/smart_ptr/make_shared.hpp>
 #include <boost/numeric/conversion/cast.hpp>
 #include <Sluift/Lua/Check.h>
 #include <Sluift/Lua/Exception.h>
 
 using namespace Swift;
 
 StatusShowConvertor::StatusShowConvertor() : GenericLuaElementConvertor<StatusShow>("show") {
 }
 
 StatusShowConvertor::~StatusShowConvertor() {
 }
 
 boost::shared_ptr<StatusShow> StatusShowConvertor::doConvertFromLua(lua_State* L) {
 	boost::shared_ptr<StatusShow> result = boost::make_shared<StatusShow>();
 	lua_getfield(L, -1, "type");
 	if (lua_isstring(L, -1)) {
 		result->setType(convertStatusShowTypeFromString(lua_tostring(L, -1)));
 	}
 	lua_pop(L, 1);
 	return result;
 }
 
 void StatusShowConvertor::doConvertToLua(lua_State* L, boost::shared_ptr<StatusShow> payload) {
 	lua_createtable(L, 0, 0);
-   	const std::string show = convertStatusShowTypeToString(payload->getType());
+	const std::string show = convertStatusShowTypeToString(payload->getType());
 	if (!show.empty()) {
 		lua_pushstring(L, show.c_str());
 		lua_setfield(L, -2, "type");
 	}
 }
 
 std::string StatusShowConvertor::convertStatusShowTypeToString(const StatusShow::Type &show) {
 	switch (show) {
-		case StatusShow::Online: return "online"; break;
-		case StatusShow::FFC: return "ffc"; break;
-		case StatusShow::Away: return "away"; break;
-		case StatusShow::XA: return "xa"; break;
-		case StatusShow::DND: return "dnd"; break;
-		case StatusShow::None: return ""; break;
+		case StatusShow::Online: return "online";
+		case StatusShow::FFC: return "ffc";
+		case StatusShow::Away: return "away";
+		case StatusShow::XA: return "xa";
+		case StatusShow::DND: return "dnd";
+		case StatusShow::None: return "";
 	}
 	assert(false);
 	return "";
 }
 
 StatusShow::Type StatusShowConvertor::convertStatusShowTypeFromString(const std::string& show) {
 	if (show == "online") {
 		return StatusShow::Online;
 	}
 	else if (show == "ffc") {
 		return StatusShow::FFC;
 	}
 	else if (show == "away") {
 		return StatusShow::Away;
 	}
 	else if (show == "xa") {
 		return StatusShow::XA;
 	}
 	else if (show == "dnd") {
 		return StatusShow::DND;
 	}
 	else {
 		throw Lua::Exception("Illegal status show: '" + show + "'");
 	}
 }
diff --git a/Sluift/Helpers.cpp b/Sluift/Helpers.cpp
index 29e2b04..756ae59 100644
--- a/Sluift/Helpers.cpp
+++ b/Sluift/Helpers.cpp
@@ -1,62 +1,65 @@
 /*
  * Copyright (c) 2013-2014 Kevin Smith and Remko Tronçon
  * Licensed under the GNU General Public License.
  * See the COPYING file for more information.
  */
 
 #include <Sluift/Helpers.h>
 
 #include <Swiften/Client/ClientError.h>
 #include <Swiften/Component/ComponentError.h>
 
 using namespace Swift;
 
-template<class T> std::string Swift::getCommonErrorString(T& error) {
-	std::string reason = "Disconnected: ";
-	switch(error.getType()) {
-		case T::UnknownError: reason += "Unknown Error"; break;
-		case T::ConnectionError: reason += "Error connecting to server"; break;
-		case T::ConnectionReadError: reason += "Error while receiving server data"; break;
-		case T::ConnectionWriteError: reason += "Error while sending data to the server"; break;
-		case T::XMLError: reason += "Error parsing server data"; break;
-		case T::AuthenticationFailedError: reason += "Login/password invalid"; break;
-		case T::UnexpectedElementError: reason += "Unexpected response"; break;
-	}
-	return reason;
-}
-
 std::string Swift::getErrorString(const ClientError& error) {
-	std::string reason = getCommonErrorString(error);
+	std::string reason = "Disconnected: ";
 	switch(error.getType()) {
+		case ClientError::UnknownError: reason += "Unknown Error"; break;
+		case ClientError::ConnectionError: reason += "Error connecting to server"; break;
+		case ClientError::ConnectionReadError: reason += "Error while receiving server data"; break;
+		case ClientError::ConnectionWriteError: reason += "Error while sending data to the server"; break;
+		case ClientError::XMLError: reason += "Error parsing server data"; break;
+		case ClientError::AuthenticationFailedError: reason += "Login/password invalid"; break;
+		case ClientError::UnexpectedElementError: reason += "Unexpected response"; break;
 		case ClientError::DomainNameResolveError: reason += "Unable to find server"; break;
 		case ClientError::CompressionFailedError: reason += "Error while compressing stream"; break;
 		case ClientError::ServerVerificationFailedError: reason += "Server verification failed"; break;
 		case ClientError::NoSupportedAuthMechanismsError: reason += "Authentication mechanisms not supported"; break;
 		case ClientError::ResourceBindError: reason += "Error binding resource"; break;
 		case ClientError::RevokedError: reason += "Certificate got revoked"; break;
 		case ClientError::RevocationCheckFailedError: reason += "Failed to do revokation check"; break;
 		case ClientError::SessionStartError: reason += "Error starting session"; break;
 		case ClientError::StreamError: reason += "Stream error"; break;
 		case ClientError::TLSError: reason += "Encryption error"; break;
 		case ClientError::ClientCertificateLoadError: reason += "Error loading certificate (Invalid password?)"; break;
 		case ClientError::ClientCertificateError: reason += "Certificate not authorized"; break;
 		case ClientError::UnknownCertificateError: reason += "Unknown certificate"; break;
 		case ClientError::CertificateCardRemoved: reason += "Certificate card removed"; break;
 		case ClientError::CertificateExpiredError: reason += "Certificate has expired"; break;
 		case ClientError::CertificateNotYetValidError: reason += "Certificate is not yet valid"; break;
 		case ClientError::CertificateSelfSignedError: reason += "Certificate is self-signed"; break;
 		case ClientError::CertificateRejectedError: reason += "Certificate has been rejected"; break;
 		case ClientError::CertificateUntrustedError: reason += "Certificate is not trusted"; break;
 		case ClientError::InvalidCertificatePurposeError: reason += "Certificate cannot be used for encrypting your connection"; break;
 		case ClientError::CertificatePathLengthExceededError: reason += "Certificate path length constraint exceeded"; break;
 		case ClientError::InvalidCertificateSignatureError: reason += "Invalid certificate signature"; break;
 		case ClientError::InvalidCAError: reason += "Invalid Certificate Authority"; break;
 		case ClientError::InvalidServerIdentityError: reason += "Certificate does not match the host identity"; break;
 	}
 	return reason;
 }
 
 std::string Swift::getErrorString(const ComponentError& error) {
-	return getCommonErrorString(error);
+	std::string reason = "Disconnected: ";
+	switch(error.getType()) {
+		case ComponentError::UnknownError: reason += "Unknown Error"; break;
+		case ComponentError::ConnectionError: reason += "Error connecting to server"; break;
+		case ComponentError::ConnectionReadError: reason += "Error while receiving server data"; break;
+		case ComponentError::ConnectionWriteError: reason += "Error while sending data to the server"; break;
+		case ComponentError::XMLError: reason += "Error parsing server data"; break;
+		case ComponentError::AuthenticationFailedError: reason += "Login/password invalid"; break;
+		case ComponentError::UnexpectedElementError: reason += "Unexpected response"; break;
+	}
+	return reason;
 }
 
diff --git a/Sluift/Helpers.h b/Sluift/Helpers.h
index d04a610..157e116 100644
--- a/Sluift/Helpers.h
+++ b/Sluift/Helpers.h
@@ -1,21 +1,20 @@
 /*
  * Copyright (c) 2013-2014 Kevin Smith and Remko Tronçon
  * Licensed under the GNU General Public License.
  * See the COPYING file for more information.
  */
 
 #pragma once
 
 #include <Swiften/Base/Override.h>
 #include <Swiften/Base/API.h>
 
 #include <string>
 
 namespace Swift {
 	class ClientError;
 	class ComponentError;
 
-	template<typename T> std::string getCommonErrorString(T& error);
 	std::string getErrorString(const ClientError& error);
 	std::string getErrorString(const ComponentError& error);
 }
diff --git a/Sluift/SluiftComponent.cpp b/Sluift/SluiftComponent.cpp
index c08a103..c8a17a7 100644
--- a/Sluift/SluiftComponent.cpp
+++ b/Sluift/SluiftComponent.cpp
@@ -47,71 +47,71 @@ void SluiftComponent::connect(const std::string& host, int port) {
 void SluiftComponent::setTraceEnabled(bool b) {
 	if (b && !tracer) {
 		tracer = new ComponentXMLTracer(component);
 	}
 	else if (!b && tracer) {
 		delete tracer;
 		tracer = NULL;
 	}
 }
 
 void SluiftComponent::waitConnected(int timeout) {
 	Watchdog watchdog(timeout, networkFactories->getTimerFactory());
 	while (!watchdog.getTimedOut() && !disconnectedError && !component->isAvailable()) {
 		eventLoop->runUntilEvents();
 	}
 	if (watchdog.getTimedOut()) {
 		component->disconnect();
 		throw Lua::Exception("Timeout while connecting");
 	}
 	if (disconnectedError) {
 		throw Lua::Exception(getErrorString(*disconnectedError));
 	}
 }
 
 bool SluiftComponent::isConnected() const {
 	return component->isAvailable();
 }
 
 void SluiftComponent::disconnect() {
 	component->disconnect();
 	while (component->isAvailable()) {
 		eventLoop->runUntilEvents();
 	}
 }
 
-void SluiftComponent::setSoftwareVersion(const std::string& name, const std::string& version, const std::string& os) {
+void SluiftComponent::setSoftwareVersion(const std::string& name, const std::string& version, const std::string& /* os */) {
 	component->setSoftwareVersion(name, version);
 }
 
 boost::optional<SluiftComponent::Event> SluiftComponent::getNextEvent(
 		int timeout, boost::function<bool (const Event&)> condition) {
 	Watchdog watchdog(timeout, networkFactories->getTimerFactory());
 	size_t currentIndex = 0;
 	while (true) {
 		// Look for pending events in the queue
 		while (currentIndex < pendingEvents.size()) {
 			Event event = pendingEvents[currentIndex];
 			if (!condition || condition(event)) {
 				pendingEvents.erase(
 						pendingEvents.begin() 
 						+ boost::numeric_cast<int>(currentIndex));
 				return event;
 			}
 			++currentIndex;
 		}
 
 		// Wait for new events
 		while (!watchdog.getTimedOut() && currentIndex >= pendingEvents.size() && component->isAvailable()) {
 			eventLoop->runUntilEvents();
 		}
 
 		// Finish if we're disconnected or timed out
 		if (watchdog.getTimedOut() || !component->isAvailable()) {
 			return boost::optional<Event>();
 		}
 	}
 }
 
 void SluiftComponent::handleIncomingMessage(boost::shared_ptr<Message> stanza) {
 	pendingEvents.push_back(Event(stanza));
 }
diff --git a/Sluift/SluiftComponent.h b/Sluift/SluiftComponent.h
index 3d5792b..ba848e1 100644
--- a/Sluift/SluiftComponent.h
+++ b/Sluift/SluiftComponent.h
@@ -66,43 +66,42 @@ namespace Swift {
 			bool isConnected() const;
 			void setTraceEnabled(bool b);
 
 			template<typename REQUEST_TYPE>
 			Sluift::Response sendRequest(REQUEST_TYPE request, int timeout) {
 				boost::signals::scoped_connection c = request->onResponse.connect(
 						boost::bind(&SluiftComponent::handleRequestResponse, this, _1, _2));
 				return doSendRequest(request, timeout);
 			}
 
 			template<typename REQUEST_TYPE>
 			Sluift::Response sendVoidRequest(REQUEST_TYPE request, int timeout) {
 				boost::signals::scoped_connection c = request->onResponse.connect(
 						boost::bind(&SluiftComponent::handleRequestResponse, this, boost::shared_ptr<Payload>(), _1));
 				return doSendRequest(request, timeout);
 			}
 
 			void disconnect();
 			void setSoftwareVersion(const std::string& name, const std::string& version, const std::string& os);
 			boost::optional<SluiftComponent::Event> getNextEvent(int timeout, 
 					boost::function<bool (const Event&)> condition = 0);
 
 		private:
 			Sluift::Response doSendRequest(boost::shared_ptr<Request> request, int timeout);
 
 			void handleIncomingMessage(boost::shared_ptr<Message> stanza);
 			void handleIncomingPresence(boost::shared_ptr<Presence> stanza);
 			void handleRequestResponse(boost::shared_ptr<Payload> response, boost::shared_ptr<ErrorPayload> error);
 			void handleError(const boost::optional<ComponentError>& error);
 		
 		private:
 			NetworkFactories* networkFactories;
 			SimpleEventLoop* eventLoop;
 			Component* component;
 			ComponentXMLTracer* tracer;
-			bool rosterReceived;
 			std::deque<Event> pendingEvents;
 			boost::optional<ComponentError> disconnectedError;
 			bool requestResponseReceived;
 			boost::shared_ptr<Payload> requestResponse;
 			boost::shared_ptr<ErrorPayload> requestError;
 	};
 }
diff --git a/Swift/Controllers/Chat/ChatsManager.cpp b/Swift/Controllers/Chat/ChatsManager.cpp
index 32e25a2..3ff2a3d 100644
--- a/Swift/Controllers/Chat/ChatsManager.cpp
+++ b/Swift/Controllers/Chat/ChatsManager.cpp
@@ -365,71 +365,70 @@ void ChatsManager::handleBookmarksReady() {
 	}
 }
 
 void ChatsManager::handleMUCBookmarkAdded(const MUCBookmark& bookmark) {
 	std::map<JID, MUCController*>::iterator it = mucControllers_.find(bookmark.getRoom());
 	if (it == mucControllers_.end() && bookmark.getAutojoin()) {
 		handleJoinMUCRequest(bookmark.getRoom(), bookmark.getPassword(), bookmark.getNick(), false, false, false  );
 	}
 	chatListWindow_->addMUCBookmark(bookmark);
 }
 
 void ChatsManager::handleMUCBookmarkRemoved(const MUCBookmark& bookmark) {
 	chatListWindow_->removeMUCBookmark(bookmark);
 }
 
 ChatListWindow::Chat ChatsManager::createChatListChatItem(const JID& jid, const std::string& activity, bool privateMessage) {
 	int unreadCount = 0;
 	if (mucRegistry_->isMUC(jid)) {
 		MUCController* controller = mucControllers_[jid.toBare()];
 		StatusShow::Type type = StatusShow::None;
 		std::string nick = "";
 		std::string password = "";
 		if (controller) {
 			unreadCount = controller->getUnreadCount();
 			if (controller->isJoined()) {
 				type = StatusShow::Online;
 			}
 			nick = controller->getNick();
 
 			if (controller->getPassword()) {
 				password = *controller->getPassword();
 			}
 
 			if (controller->isImpromptu()) {
 				ChatListWindow::Chat chat = ChatListWindow::Chat(jid, jid.toString(), activity, unreadCount, type, boost::filesystem::path(), true, privateMessage, nick, password);
-				typedef std::pair<std::string, JID> StringJIDPair;
 				std::map<std::string, JID> participants = controller->getParticipantJIDs();
 				chat.impromptuJIDs = participants;
 				return chat;
 			}
 		}
 		return ChatListWindow::Chat(jid, jid.toString(), activity, unreadCount, type, boost::filesystem::path(), true, privateMessage, nick, password);
 	} else {
 		ChatController* controller = getChatControllerIfExists(jid, false);
 		if (controller) {
 			unreadCount = controller->getUnreadCount();
 		}
 		JID bareishJID = mucRegistry_->isMUC(jid.toBare()) ? jid : jid.toBare();
 		Presence::ref presence = presenceOracle_->getHighestPriorityPresence(bareishJID);
 		StatusShow::Type type = presence ? presence->getShow() : StatusShow::None;
 		boost::filesystem::path avatarPath = avatarManager_ ? avatarManager_->getAvatarPath(bareishJID) : boost::filesystem::path();
 		return ChatListWindow::Chat(bareishJID, nickResolver_->jidToNick(bareishJID), activity, unreadCount, type, avatarPath, false, privateMessage);
 	}
 }
 
 void ChatsManager::handleChatActivity(const JID& jid, const std::string& activity, bool isMUC) {
 	const bool privateMessage = mucRegistry_->isMUC(jid.toBare()) && !isMUC;
 	ChatListWindow::Chat chat = createChatListChatItem(jid, activity, privateMessage);
 	/* FIXME: handle nick changes */
 	appendRecent(chat);
 	handleUnreadCountChanged(NULL);
 	saveRecents();
 }
 
 void ChatsManager::handleChatClosed(const JID& /*jid*/) {
 	cleanupPrivateMessageRecents();
 	chatListWindow_->setRecents(recentChats_);
 }
 
 void ChatsManager::handleUnreadCountChanged(ChatControllerBase* controller) {
 	int unreadTotal = 0;
author	Tobias Markmann <tm@ayena.de>	2014-10-23 12:24:36 (GMT)
committer	Tobias Markmann <tm@ayena.de>	2014-10-23 12:24:36 (GMT)
commit	fa67c2b239d9c7fc508205ea17724322011194f4 (patch)
tree	33c09d0a38bbf2a61b9f0dbadc048d7665542972
parent	052190912463d8ea36979fd5a5e9a298588dce4f (diff)
download	swift-contrib-fa67c2b239d9c7fc508205ea17724322011194f4.zip swift-contrib-fa67c2b239d9c7fc508205ea17724322011194f4.tar.bz2