Merge remote-tracking branch 'refs/remotes/origin/command_case_sensitivity'

Author: Ayuto

src/core/modules/commands/commands.h

@@ -45,6 +45,26 @@ enum CommandReturn
 };
 
 
+//-----------------------------------------------------------------------------
+// Functions.
+//-----------------------------------------------------------------------------
+template<class InputMap, class Result>
+bool find_manager(InputMap input, const char* name, Result& result)
+{
+	InputMap::iterator iter = input.begin();
+	while (iter != input.end())
+	{
+		// TODO: Doesn't not work for multi-byte characters
+		if (V_stricmp(iter->second->GetName(), name) == 0) {
+			result = iter;
+			return true;
+		}
+		++iter;
+	}
+	return false;
+}
+
+
 //-----------------------------------------------------------------------------
 // CCommand extension class.
 //-----------------------------------------------------------------------------

src/core/modules/commands/commands_client.cpp

@@ -63,34 +63,30 @@ static CListenerManager s_ClientCommandFilters;
 //-----------------------------------------------------------------------------
 CClientCommandManager* GetClientCommand(const char* szName)
 {
-	// Find if the given name is a registered client command
-	ClientCommandMap::iterator commandMapIter = g_ClientCommandMap.find(szName);
-	if( commandMapIter == g_ClientCommandMap.end())
+	CClientCommandManager* manager = NULL;
+	ClientCommandMap::iterator iter;
+	if (!find_manager<ClientCommandMap, ClientCommandMap::iterator>(g_ClientCommandMap, szName, iter))
 	{
-		// If the command is not already registered, add the name and the CClientCommandManager instance to the mapping
-		g_ClientCommandMap.insert(std::make_pair(szName, new CClientCommandManager(szName)));
-
-		// Get the client command in the mapping
-		commandMapIter = g_ClientCommandMap.find(szName);
+		manager = new CClientCommandManager(szName);
+		g_ClientCommandMap.insert(std::make_pair(szName, manager));
 	}
-
-	// Return the CClientCommandManager instance for the command
-	return commandMapIter->second;
+	else
+	{
+		manager = iter->second;
+	}
+	return manager;
 }
 
 //-----------------------------------------------------------------------------
 // Removes a CClientCommandManager instance for the given name.
 //-----------------------------------------------------------------------------
 void RemoveCClientCommandManager(const char* szName)
 {
-	// Find if the given name is a registered client command
-	ClientCommandMap::iterator commandMapIter = g_ClientCommandMap.find(szName);
-	if( commandMapIter != g_ClientCommandMap.end())
+	ClientCommandMap::iterator iter;
+	if (find_manager<ClientCommandMap, ClientCommandMap::iterator>(g_ClientCommandMap, szName, iter))
 	{
-		// If the command is registered, delete the CClientCommandManager instance
-		//		and remove the command from the mapping
-		delete commandMapIter->second;
-		g_ClientCommandMap.erase(commandMapIter);
+		delete iter->second;
+		g_ClientCommandMap.erase(iter);
 	}
 }
 
@@ -140,24 +136,15 @@ PLUGIN_RESULT DispatchClientCommand(edict_t* pEntity, const CCommand &command)
 		END_BOOST_PY_NORET()
 	}
 
-	// Get the command's name
-	const char* szCommand = command.Arg(0);
-
-	// Find if the command exists in the mapping
-	ClientCommandMap::iterator commandMapIter = g_ClientCommandMap.find(szCommand);
-	if( commandMapIter != g_ClientCommandMap.end() )
+	ClientCommandMap::iterator iter;
+	if (find_manager<ClientCommandMap, ClientCommandMap::iterator>(g_ClientCommandMap, command.Arg(0), iter))
 	{
-		// If the command exists, get the CClientCommandManager instance and call its Dispatch method
-		CClientCommandManager* pCClientCommandManager = commandMapIter->second;
-
-		// Does the command need to be blocked?
-		if( !pCClientCommandManager->Dispatch(command, iIndex))
+		if( !iter->second->Dispatch(command, iIndex))
 		{
 			// Block the command
 			return PLUGIN_STOP;
 		}
 	}
-
 	return PLUGIN_CONTINUE;
 }
 
@@ -239,3 +226,8 @@ CommandReturn CClientCommandManager::Dispatch( const CCommand& command, int iInd
 
 	return CONTINUE;
 }
+
+const char* CClientCommandManager::GetName()
+{
+	return m_Name;
+}

src/core/modules/commands/commands_client.h

@@ -54,6 +54,8 @@ class CClientCommandManager
 
 	CommandReturn Dispatch(const CCommand& ccommand, int iIndex);
 
+	const char* GetName();
+
 private:
 	CUtlVector<object> m_vecCallables;
 	const char* m_Name;

src/core/modules/commands/commands_say.cpp

@@ -97,34 +97,30 @@ void BaseSayCommand::UnregisterCommands()
 //-----------------------------------------------------------------------------
 CSayCommandManager* GetSayCommand(const char* szName)
 {
-	// Find if the given name is a registered say command
-	SayCommandMap::iterator commandMapIter = g_SayCommandMap.find(szName);
-	if( commandMapIter == g_SayCommandMap.end())
+	CSayCommandManager* manager = NULL;
+	SayCommandMap::iterator iter;
+	if (!find_manager<SayCommandMap, SayCommandMap::iterator>(g_SayCommandMap, szName, iter))
 	{
-		// If the command is not already registered, add the name and the CSayCommandManager instance to the mapping
-		g_SayCommandMap.insert(std::make_pair(szName, new CSayCommandManager(szName)));
-
-		// Get the say command in the mapping
-		commandMapIter = g_SayCommandMap.find(szName);
+		manager = new CSayCommandManager(szName);
+		g_SayCommandMap.insert(std::make_pair(szName, manager));
 	}
-
-	// Return the CSayCommandManager instance for the command
-	return commandMapIter->second;
+	else
+	{
+		manager = iter->second;
+	}
+	return manager;
 }
 
 //-----------------------------------------------------------------------------
 // Removes a CSayCommandManager instance for the given name.
 //-----------------------------------------------------------------------------
 void RemoveCSayCommandManager(const char* szName)
 {
-	// Find if the given name is a registered say command
-	SayCommandMap::iterator commandMapIter = g_SayCommandMap.find(szName);
-	if( commandMapIter != g_SayCommandMap.end() )
+	SayCommandMap::iterator iter;
+	if (find_manager<SayCommandMap, SayCommandMap::iterator>(g_SayCommandMap, szName, iter))
 	{
-		// If the command is registered, delete the CSayCommandManager instance
-		//		and remove the command from the mapping
-		delete commandMapIter->second;
-		g_SayCommandMap.erase(commandMapIter);
+		delete iter->second;
+		g_SayCommandMap.erase(iter);
 	}
 }
 
@@ -268,15 +264,11 @@ void SayConCommand::Dispatch( const CCommand& command )
 		END_BOOST_PY_NORET()
 	}
 
-	// Find if the command is registered
-	SayCommandMap::iterator commandMapIter = g_SayCommandMap.find(stripped_command[0]);
-	if( commandMapIter != g_SayCommandMap.end() )
+	
+	SayCommandMap::iterator iter;
+	if (find_manager<SayCommandMap, SayCommandMap::iterator>(g_SayCommandMap, stripped_command[0], iter))
 	{
-		// Get the CSayCommandManager instance for the command
-		CSayCommandManager* pCSayCommandManager = commandMapIter->second;
-		
-		// Call the command and see it wants to block the command
-		if( pCSayCommandManager->Dispatch(stripped_command, iIndex, bTeamOnly)  == BLOCK)
+		if(iter->second->Dispatch(stripped_command, iIndex, bTeamOnly)  == BLOCK)
 		{
 			// Block the command
 			return;
@@ -370,6 +362,11 @@ CommandReturn CSayCommandManager::Dispatch( const CCommand& command, int iIndex,
 	return CONTINUE;
 }
 
+const char* CSayCommandManager::GetName()
+{
+	return m_Name;
+}
+
 //-----------------------------------------------------------------------------
 // Registers the say and say_team commands.
 //-----------------------------------------------------------------------------

src/core/modules/commands/commands_say.h

@@ -84,6 +84,8 @@ class CSayCommandManager
 
 	CommandReturn Dispatch(const CCommand& ccommand, int iIndex, bool bTeamOnly);
 
+	const char* GetName();
+
 private:
 	const char* m_Name;
 	CUtlVector<object> m_vecCallables;

src/core/modules/commands/commands_server.cpp

@@ -82,34 +82,30 @@ ServerCommandMap g_ServerCommandMap;
 CServerCommandManager* GetServerCommand(const char* szName,
 	const char* szHelpText = 0, int iFlags = 0)
 {
-	// Find if the given name is a registered server command
-	ServerCommandMap::iterator commandMapIter = g_ServerCommandMap.find(szName);
-	if( commandMapIter == g_ServerCommandMap.end())
+	CServerCommandManager* manager = NULL;
+	ServerCommandMap::iterator iter;
+	if (!find_manager<ServerCommandMap, ServerCommandMap::iterator>(g_ServerCommandMap, szName, iter))
 	{
-		// If the command is not already registered, add the name and the CServerCommandManager instance to the mapping
-		g_ServerCommandMap.insert(std::make_pair(szName, CServerCommandManager::CreateCommand(szName, szHelpText, iFlags)));
-
-		// Get the server command in the mapping
-		commandMapIter = g_ServerCommandMap.find(szName);
+		manager = CServerCommandManager::CreateCommand(szName, szHelpText, iFlags);
+		g_ServerCommandMap.insert(std::make_pair(szName, manager));
 	}
-
-	// Return the CServerCommandManager instance for the command
-	return commandMapIter->second;
+	else
+	{
+		manager = iter->second;
+	}
+	return manager;
 }
 
 //-----------------------------------------------------------------------------
 // Removes a CServerCommandManager instance for the given name.
 //-----------------------------------------------------------------------------
 void RemoveCServerCommandManager(const char* szName)
 {
-	// Find if the given name is a registered server command
-	ServerCommandMap::iterator commandMapIter = g_ServerCommandMap.find(szName);
-	if( commandMapIter != g_ServerCommandMap.end())
+	ServerCommandMap::iterator iter;
+	if (find_manager<ServerCommandMap, ServerCommandMap::iterator>(g_ServerCommandMap, szName, iter))
 	{
-		// If the command is registered, delete the CServerCommandManager instance
-		//		and remove the command from the mapping
-		delete commandMapIter->second;
-		g_ServerCommandMap.erase(commandMapIter);
+		delete iter->second;
+		g_ServerCommandMap.erase(iter);
 	}
 }