Removed references to tr1 now that c++11 works

engine/server/application/CentralServer/src/shared/CentralServer.h

@@ -7,7 +7,7 @@
 
 //-----------------------------------------------------------------------
 #pragma warning(disable : 4100)
-#include <tr1/unordered_map>
+#include <unordered_map>
 #include <map>
 #include <string>
 #include <vector>
@@ -61,10 +61,10 @@ public:
 private:
 	typedef std::vector<ConnectionServerConnection *>                 ConnectionServerConnectionList;
 	typedef std::map<NetworkId, CentralObject>                       CentralObjectMap;
-	typedef std::tr1::unordered_multimap<SceneId, GameServerConnection *> SceneGameMap;
+	typedef std::unordered_multimap<SceneId, GameServerConnection *> SceneGameMap;
 
 	typedef std::pair<SceneGameMap::const_iterator, SceneGameMap::const_iterator> ServersList;
-	typedef std::tr1::unordered_map<uint32, ConnectionServerConnection *>                   ConnectionServerSUIDMap;
+	typedef std::unordered_map<uint32, ConnectionServerConnection *>                   ConnectionServerSUIDMap;
 
 	typedef std::map<NetworkId, std::pair<SceneId, time_t> >                      PlayerSceneMapType;
 

engine/server/application/ChatServer/src/shared/ChatInterface.cpp

@@ -89,7 +89,7 @@ namespace ChatInterfaceNamespace
 	static int s_maxHeadersToSendToClientPerInterval;
 
 	// to prevent sending duplicate room chat message
-	std::tr1::unordered_map<unsigned, std::pair<unsigned, unsigned> > s_mostRecentRoomChatMessage;
+	std::unordered_map<unsigned, std::pair<unsigned, unsigned> > s_mostRecentRoomChatMessage;
 }
 
 using namespace ChatInterfaceNamespace;
@@ -356,7 +356,7 @@ void ChatInterface::OnGetRoom(unsigned track, unsigned result, const ChatRoom *r
 	}
 	std::string lowerRoomName = toLower(roomName);
 	unsigned sequence = (unsigned)user;
-	std::tr1::unordered_map<std::string, ChatServerRoomOwner>::iterator f = roomList.find(lowerRoomName);
+	std::unordered_map<std::string, ChatServerRoomOwner>::iterator f = roomList.find(lowerRoomName);
 	if (f != roomList.end() && room)
 	{
 		(*f).second.updateRoomData(room);
@@ -443,7 +443,7 @@ const ChatServerRoomOwner * ChatInterface::getRoomByName(const std::string & roo
 
 	std::string lowerRoomName = toLower(roomName);
 	const ChatServerRoomOwner * result = 0;
-	std::tr1::unordered_map<std::string, ChatServerRoomOwner>::const_iterator f = roomList.find(lowerRoomName);
+	std::unordered_map<std::string, ChatServerRoomOwner>::const_iterator f = roomList.find(lowerRoomName);
 	if(f != roomList.end())
 	{
 		result = &(*f).second;
@@ -546,7 +546,7 @@ void ChatInterface::sendMessageToAllAvatars(const GameNetworkMessage & message)
 	}
 
 	//send to all pending avatars
-	std::tr1::unordered_map<std::string, NetworkId>::iterator p = pendingAvatars.begin();
+	std::unordered_map<std::string, NetworkId>::iterator p = pendingAvatars.begin();
 	while (p != pendingAvatars.end())
 	{
 		ConnectionServerConnection * connection = 
@@ -570,7 +570,7 @@ std::string ChatInterface::getChatName(const NetworkId &id)
 {
 	ChatServer::fileLog(false, "ChatInterface", "getChatName() id(%s)", id.getValueString().c_str());
 
-    std::tr1::unordered_map<std::string, NetworkId>::iterator i;
+    std::unordered_map<std::string, NetworkId>::iterator i;
     for (i = pendingAvatars.begin(); i != pendingAvatars.end(); ++i)
     {
         if (id == (*i).second)
@@ -588,7 +588,7 @@ bool ChatInterface::sendMessageToPendingAvatar(const ChatAvatarId &id, const Gam
 {
 	ChatServer::fileLog(false, "ChatInterface", "sendMessageToPendingAvatar() id(%s) message(%s)", id.getFullName().c_str(), message.getCmdName().c_str());
 
-	std::tr1::unordered_map<std::string, NetworkId>::iterator f = pendingAvatars.find(id.name);
+	std::unordered_map<std::string, NetworkId>::iterator f = pendingAvatars.find(id.name);
 	if (f != pendingAvatars.end())
 	{
 		ConnectionServerConnection * connection = 
@@ -609,7 +609,7 @@ bool ChatInterface::sendMessageToPendingAvatar(const ChatAvatarId &id, const Gam
 
 //-----------------------------------------------------------------------
 
-const std::tr1::unordered_map<std::string, ChatServerRoomOwner> & ChatInterface::getRoomList() const
+const std::unordered_map<std::string, ChatServerRoomOwner> & ChatInterface::getRoomList() const
 {
 	return roomList;
 }
@@ -618,7 +618,7 @@ const std::tr1::unordered_map<std::string, ChatServerRoomOwner> & ChatInterface:
 
 void ChatInterface::updateRooms()
 {
-	std::tr1::unordered_map<std::string, ChatServerRoomOwner>::const_iterator i;
+	std::unordered_map<std::string, ChatServerRoomOwner>::const_iterator i;
 	for(i = roomList.begin(); i != roomList.end(); ++i)
 	{
 		ChatServerRoomOwner & roomOwner = const_cast<ChatServerRoomOwner &>((*i).second);
@@ -656,7 +656,7 @@ void ChatInterface::requestRoomList(const NetworkId & id, ConnectionServerConnec
 
 	++roomQueriesThisFrame;
 
-	std::tr1::unordered_map<std::string, ChatServerRoomOwner>::const_iterator i;
+	std::unordered_map<std::string, ChatServerRoomOwner>::const_iterator i;
 	std::vector<ChatRoomData> rooms;
 	const ChatAvatar * target = ChatServer::getAvatarByNetworkId(id);
 	ChatAvatarId requestingAvatar;
@@ -1010,7 +1010,7 @@ void ChatInterface::OnReceiveAddModeratorRoom(const ChatAvatar *srcAvatar, const
 		makeRoomName(destRoom, roomName);
 
 		// Update info about the room
-		std::tr1::unordered_map<std::string, ChatServerRoomOwner>::iterator f = roomList.find(toLower(roomName));
+		std::unordered_map<std::string, ChatServerRoomOwner>::iterator f = roomList.find(toLower(roomName));
 		if(f != roomList.end())
 			(*f).second.updateRoomData(destRoom);
 
@@ -1123,7 +1123,7 @@ void ChatInterface::OnReceiveRemoveModeratorRoom(const ChatAvatar *srcAvatar, co
 		makeRoomName(destRoom, roomName);
 
 		// Update info about the room
-		std::tr1::unordered_map<std::string, ChatServerRoomOwner>::iterator f = roomList.find(toLower(roomName));
+		std::unordered_map<std::string, ChatServerRoomOwner>::iterator f = roomList.find(toLower(roomName));
 		if(f != roomList.end())
 			(*f).second.updateRoomData(destRoom);
 
@@ -1473,7 +1473,7 @@ void ChatInterface::OnLoginAvatar(unsigned track, unsigned result, const ChatAva
 		
 		ChatAvatarId failedAvatarId;
 		makeAvatarId(ChatUnicodeString(info->name.data(), info->name.size()), ChatUnicodeString(info->address.data(), info->address.size()), failedAvatarId); 
-		std::tr1::unordered_map<std::string, NetworkId>::iterator f = pendingAvatars.find(failedAvatarId.name);
+		std::unordered_map<std::string, NetworkId>::iterator f = pendingAvatars.find(failedAvatarId.name);
 		if (f != pendingAvatars.end())
 		{
 			pendingAvatars.erase(f);
@@ -1511,7 +1511,7 @@ void ChatInterface::OnLoginAvatar(unsigned track, unsigned result, const ChatAva
 	else
 	{
 		// look up a connection for this avatar
-		std::tr1::unordered_map<std::string, NetworkId>::iterator f = pendingAvatars.find(id.name);
+		std::unordered_map<std::string, NetworkId>::iterator f = pendingAvatars.find(id.name);
 		if(f != pendingAvatars.end())
 		{
 			GenericValueTypeMessage<NetworkId> const avatarConnectedMessage("ChatAvatarConnected", (*f).second);
@@ -1536,7 +1536,7 @@ void ChatInterface::OnLoginAvatar(unsigned track, unsigned result, const ChatAva
 				ChatServer::chatConnectedAvatar((*f).second, *newAvatar);
 				
 				// flush chat messages pending for this avatar
-				std::tr1::unordered_map<NetworkId, std::vector<Archive::ByteStream>, NetworkId::Hash >::iterator df = deferredChatMessages.find((*f).second);
+				std::unordered_map<NetworkId, std::vector<Archive::ByteStream>, NetworkId::Hash >::iterator df = deferredChatMessages.find((*f).second);
 				if(df != deferredChatMessages.end())
 				{
 					std::vector<Archive::ByteStream> & v = (*df).second;
@@ -1642,7 +1642,7 @@ void ChatInterface::OnGetRoomSummaries(unsigned track, unsigned result, unsigned
 			makeRoomName(&(foundRooms[i]), roomName);
 
 			std::string lowerRoomName = toLower(roomName);
-			std::tr1::unordered_map<std::string, ChatServerRoomOwner>::const_iterator f = roomList.find(lowerRoomName);
+			std::unordered_map<std::string, ChatServerRoomOwner>::const_iterator f = roomList.find(lowerRoomName);
 			if(f == roomList.end())
 			{
 				RequestGetRoom(foundRooms[i].getRoomAddress(), NULL);
@@ -1660,7 +1660,7 @@ void ChatInterface::OnGetRoomSummaries(unsigned track, unsigned result, unsigned
 const ChatServerRoomOwner *ChatInterface::getRoomOwner(const std::string & roomName)
 {
 	std::string lowerName = toLower(roomName);
-	std::tr1::unordered_map<std::string, ChatServerRoomOwner>::const_iterator f = roomList.find(lowerName);
+	std::unordered_map<std::string, ChatServerRoomOwner>::const_iterator f = roomList.find(lowerName);
 	if(f != roomList.end())
 	{
 		return &((*f).second);
@@ -1672,7 +1672,7 @@ const ChatServerRoomOwner *ChatInterface::getRoomOwner(const std::string & roomN
 
 ChatServerRoomOwner *ChatInterface::getRoomOwner(unsigned roomId)
 {
-	std::tr1::unordered_map<std::string, ChatServerRoomOwner>::iterator f = roomList.begin();
+	std::unordered_map<std::string, ChatServerRoomOwner>::iterator f = roomList.begin();
 	while (f != roomList.end())
 	{
 		if ((*f).second.getRoomData().id == roomId)
@@ -1709,7 +1709,7 @@ void ChatInterface::OnReceiveDestroyRoom(const ChatAvatar *srcAvatar, const Chat
 		std::string roomName;
 		makeRoomName(destRoom, roomName);
 		std::string lowerName = toLower(roomName);
-		std::tr1::unordered_map<std::string, ChatServerRoomOwner>::iterator f = roomList.find(lowerName);
+		std::unordered_map<std::string, ChatServerRoomOwner>::iterator f = roomList.find(lowerName);
 		if(f != roomList.end())
 		{
 			roomList.erase(f);
@@ -1753,7 +1753,7 @@ void ChatInterface::OnDestroyRoom(unsigned track, unsigned result, void *user)
 		if (result == CHATRESULT_SUCCESS)
 		{
 			std::string lowerName = toLower(owner->getRoomData().path);
-			std::tr1::unordered_map<std::string, ChatServerRoomOwner>::iterator f = roomList.find(lowerName);
+			std::unordered_map<std::string, ChatServerRoomOwner>::iterator f = roomList.find(lowerName);
 			if(f != roomList.end())
 			{
 				roomList.erase(f);
@@ -1985,7 +1985,7 @@ void ChatInterface::OnReceiveEnterRoom(const ChatAvatar *srcAvatar, const ChatRo
 		makeRoomName(destRoom, roomName);
 
 		// Update info about the room
-		std::tr1::unordered_map<std::string, ChatServerRoomOwner>::iterator f = roomList.find(toLower(roomName));
+		std::unordered_map<std::string, ChatServerRoomOwner>::iterator f = roomList.find(toLower(roomName));
 		if(f != roomList.end())
 			(*f).second.updateRoomData(destRoom);
 
@@ -2182,7 +2182,7 @@ void ChatInterface::OnReceiveAddBanRoom(const ChatAvatar *srcAvatar, const ChatA
 		makeRoomName(destRoom, roomName);
 
 		// Update info about the room
-		std::tr1::unordered_map<std::string, ChatServerRoomOwner>::iterator f = roomList.find(toLower(roomName));
+		std::unordered_map<std::string, ChatServerRoomOwner>::iterator f = roomList.find(toLower(roomName));
 		if(f != roomList.end())
 			(*f).second.updateRoomData(destRoom);
 
@@ -2300,7 +2300,7 @@ void ChatInterface::OnReceiveRemoveBanRoom(const ChatAvatar *srcAvatar, const Ch
 		makeRoomName(destRoom, roomName);
 
 		// Update info about the room
-		std::tr1::unordered_map<std::string, ChatServerRoomOwner>::iterator f = roomList.find(toLower(roomName));
+		std::unordered_map<std::string, ChatServerRoomOwner>::iterator f = roomList.find(toLower(roomName));
 		if(f != roomList.end())
 			(*f).second.updateRoomData(destRoom);
 
@@ -2419,7 +2419,7 @@ void ChatInterface::OnReceiveAddInviteRoom(const ChatAvatar *srcAvatar, const Ch
 		makeRoomName(destRoom, roomName);
 
 		// Update info about the room
-		std::tr1::unordered_map<std::string, ChatServerRoomOwner>::iterator f = roomList.find(toLower(roomName));
+		std::unordered_map<std::string, ChatServerRoomOwner>::iterator f = roomList.find(toLower(roomName));
 		if(f != roomList.end())
 			(*f).second.updateRoomData(destRoom);
 
@@ -2518,7 +2518,7 @@ void ChatInterface::OnReceiveRemoveInviteRoom(const ChatAvatar *srcAvatar, const
 		makeRoomName(destRoom, roomName);
 
 		// Update info about the room
-		std::tr1::unordered_map<std::string, ChatServerRoomOwner>::iterator f = roomList.find(toLower(roomName));
+		std::unordered_map<std::string, ChatServerRoomOwner>::iterator f = roomList.find(toLower(roomName));
 		if(f != roomList.end())
 			(*f).second.updateRoomData(destRoom);
 
@@ -2599,7 +2599,7 @@ void ChatInterface::OnReceiveLeaveRoom(const ChatAvatar *srcAvatar, const ChatRo
 		makeRoomName(destRoom, roomName);
 
 		// Update info about the room
-		std::tr1::unordered_map<std::string, ChatServerRoomOwner>::iterator const f = roomList.find(toLower(roomName));
+		std::unordered_map<std::string, ChatServerRoomOwner>::iterator const f = roomList.find(toLower(roomName));
 		if(f != roomList.end())
 			(*f).second.updateRoomData(destRoom);
 
@@ -2719,7 +2719,7 @@ void ChatInterface::OnReceiveKickRoom(const ChatAvatar *srcAvatar, const ChatAva
 		makeRoomName(destRoom, roomName);
 
 		// Update info about the room
-		std::tr1::unordered_map<std::string, ChatServerRoomOwner>::iterator f = roomList.find(toLower(roomName));
+		std::unordered_map<std::string, ChatServerRoomOwner>::iterator f = roomList.find(toLower(roomName));
 		if(f != roomList.end())
 			(*f).second.updateRoomData(destRoom);
 
@@ -2940,7 +2940,7 @@ void ChatInterface::OnReceiveRoomMessage(const ChatAvatar *srcAvatar, const Chat
 	{
 		unsigned const destAvatarId = destAvatar->getAvatarID();
 		unsigned const destRoomId = destRoom->getRoomID();
-		std::tr1::unordered_map<unsigned, std::pair<unsigned, unsigned> >::iterator const iterFind = s_mostRecentRoomChatMessage.find(destAvatarId);
+		std::unordered_map<unsigned, std::pair<unsigned, unsigned> >::iterator const iterFind = s_mostRecentRoomChatMessage.find(destAvatarId);
 		if (iterFind != s_mostRecentRoomChatMessage.end())
 		{
 			if ((iterFind->second.first == destRoomId) && (iterFind->second.second == messageID))

engine/server/application/ChatServer/src/shared/ChatInterface.h

@@ -12,7 +12,7 @@
 #include "ChatServerAvatarOwner.h"
 #include "ChatServerRoomOwner.h"
 #include <deque>
-#include <tr1/unordered_map>
+#include <unordered_map>
 #include <map>
 #include <set>
 #include <string>
@@ -47,7 +47,7 @@ public:
 	const NetworkId & getNetworkIdByAvatarId(const ChatAvatarId &id);
 	ChatServerAvatarOwner *getAvatarOwner(const ChatAvatar *avatar);
 	void          disconnectPlayer  (const ChatAvatarId & avatarId);
-	const std::tr1::unordered_map<std::string, ChatServerRoomOwner> &  getRoomList  () const;
+	const std::unordered_map<std::string, ChatServerRoomOwner> &  getRoomList  () const;
 
 	const ChatServerRoomOwner *getRoomOwner(const std::string &roomName);
 	ChatServerRoomOwner *getRoomOwner(unsigned roomId);
@@ -157,11 +157,11 @@ public:
 
 private:
 	std::map<ChatAvatarId, ChatServerAvatarOwner *>  avatarMap;
-	std::tr1::unordered_map<std::string, NetworkId>  pendingAvatars;
+	std::unordered_map<std::string, NetworkId>  pendingAvatars;
 	std::set<NetworkId> pendingRoomQueries;
 	int                 roomQueriesThisFrame;
-	std::tr1::unordered_map<std::string, ChatServerRoomOwner> roomList;
-	std::tr1::unordered_map<NetworkId, std::vector<Archive::ByteStream>, NetworkId::Hash >  deferredChatMessages;
+	std::unordered_map<std::string, ChatServerRoomOwner> roomList;
+	std::unordered_map<NetworkId, std::vector<Archive::ByteStream>, NetworkId::Hash >  deferredChatMessages;
 	std::map<ChatAvatarId, std::pair<unsigned long, std::deque<const ChatPersistentMessageToClient *> > > queuedHeaders;
 	std::map<unsigned, std::pair<std::pair<ChatUnicodeString, ChatUnicodeString>, int> > trackingRequestGetAnyAvatarForDestroy;
 };

engine/server/application/ChatServer/src/shared/ChatServer.cpp

@@ -71,7 +71,7 @@ namespace ChatServerNamespace
 	ChatServerMetricsData * s_chatServerMetricsData = 0;
 
 	typedef std::list<std::pair<int, time_t> > MessageList;
-	typedef std::tr1::unordered_map<Unicode::String, MessageList> PlayerMessageList;
+	typedef std::unordered_map<Unicode::String, MessageList> PlayerMessageList;
 	PlayerMessageList s_playerMessageList;
 
 	void cleanChatLog();
@@ -430,7 +430,7 @@ void ChatServer::sendToClient(const NetworkId & id, const GameNetworkMessage & m
 {
 	ChatServer::fileLog(false, "ChatServer", "sendToClient() id(%s) message(%s)", id.getValueString().c_str(), message.getCmdName().c_str());
 
-	std::tr1::unordered_map<NetworkId, ConnectionServerConnection *, NetworkId::Hash>::const_iterator f = instance().clientMap.find(id);
+	std::unordered_map<NetworkId, ConnectionServerConnection *, NetworkId::Hash>::const_iterator f = instance().clientMap.find(id);
 	if(f != instance().clientMap.end())
 	{
 		(*f).second->sendToClient(id, message);
@@ -604,7 +604,7 @@ void ChatServer::removeServices()
 ChatAvatarId ChatServer::getAvatarIdForTrackId(unsigned trackId)
 {
 	ChatServer & server = instance();
-	std::tr1::unordered_map<unsigned, NetworkId>::iterator f = server.pendingRequests.find(trackId);
+	std::unordered_map<unsigned, NetworkId>::iterator f = server.pendingRequests.find(trackId);
 	if(f != server.pendingRequests.end())
 	{
 		const ChatAvatar *avatar = getAvatarByNetworkId((*f).second);
@@ -681,11 +681,11 @@ NetworkId ChatServer::sendResponseForTrackId(unsigned trackId, const GameNetwork
 {
 	NetworkId id;
 	ChatServer & server = instance();
-	std::tr1::unordered_map<unsigned, NetworkId>::iterator f = server.pendingRequests.find(trackId);
+	std::unordered_map<unsigned, NetworkId>::iterator f = server.pendingRequests.find(trackId);
 	if(f != server.pendingRequests.end())
 	{
 		id = (*f).second;
-		std::tr1::unordered_map<NetworkId, ConnectionServerConnection *, NetworkId::Hash>::const_iterator c = server.clientMap.find((*f).second);
+		std::unordered_map<NetworkId, ConnectionServerConnection *, NetworkId::Hash>::const_iterator c = server.clientMap.find((*f).second);
 		if(c != server.clientMap.end())
 		{
 			ConnectionServerConnection * conn = (*c).second;
@@ -701,7 +701,7 @@ NetworkId ChatServer::sendResponseForTrackId(unsigned trackId, const GameNetwork
 GameServerConnection *ChatServer::getGameServerConnection(unsigned int sequence)
 {
 	GameServerConnection * result = 0;
-	std::tr1::unordered_map<unsigned int, GameServerConnection *>::iterator f = instance().gameServerConnectionMap.find(sequence);
+	std::unordered_map<unsigned int, GameServerConnection *>::iterator f = instance().gameServerConnectionMap.find(sequence);
 	if(f != instance().gameServerConnectionMap.end())
 	{
 		result = (*f).second;
@@ -724,7 +724,7 @@ void ChatServer::addGameServerConnection(unsigned int sequence, GameServerConnec
 void ChatServer::clearGameServerConnection(const GameServerConnection *connection)
 {
 	std::vector<unsigned int> removeKeyList;
-	std::tr1::unordered_map<unsigned int, GameServerConnection *>::const_iterator i;
+	std::unordered_map<unsigned int, GameServerConnection *>::const_iterator i;
 	for(i = instance().gameServerConnectionMap.begin(); i != instance().gameServerConnectionMap.end(); ++i)
 	{
 		if ((*i).second == connection)
@@ -746,7 +746,7 @@ void ChatServer::clearGameServerConnection(const GameServerConnection *connectio
 ConnectionServerConnection * ChatServer::getConnectionForCharacter(const NetworkId & characterId)
 {
 	ConnectionServerConnection * result = 0;
-	std::tr1::unordered_map<NetworkId, ConnectionServerConnection *, NetworkId::Hash>::iterator f = instance().clientMap.find(characterId);
+	std::unordered_map<NetworkId, ConnectionServerConnection *, NetworkId::Hash>::iterator f = instance().clientMap.find(characterId);
 	if(f != instance().clientMap.end())
 	{
 		result = (*f).second;
@@ -1039,7 +1039,7 @@ void ChatServer::connectPlayer(ConnectionServerConnection * connection, const un
 {
 	ChatServer::fileLog(false, "ChatServer", "connectPlayer() address(%s) suid(%u) characterName(%s) networkId(%s)", getConnectionAddress(connection).c_str(), suid, characterName.c_str(), networkId.getValueString().c_str());
 
-	std::tr1::unordered_map<NetworkId, ConnectionServerConnection *, NetworkId::Hash>::iterator cf = instance().clientMap.find(networkId);
+	std::unordered_map<NetworkId, ConnectionServerConnection *, NetworkId::Hash>::iterator cf = instance().clientMap.find(networkId);
 	if (cf != instance().clientMap.end())
 	{
 		DEBUG_WARNING(true, ("We received a chat login attempt for a player (%s) that we think is already logged in.  We're going to try to log out the old avatar then log in the new one.", characterName.c_str()));
@@ -1260,7 +1260,7 @@ void ChatServer::destroyRoom(const NetworkId & id, const unsigned int sequence,
 		ChatAvatarId destroyer(avatar->GetGameCode(), avatar->GetGameServerName(), avatar->GetCharacterName());
 
 		// can this avatar destroy the room?
-		std::tr1::unordered_map<std::string, ChatServerRoomOwner>::const_iterator i;
+		std::unordered_map<std::string, ChatServerRoomOwner>::const_iterator i;
 		for(i = instance().chatInterface->getRoomList().begin(); i != instance().chatInterface->getRoomList().end(); ++i)
 		{
 			if((*i).second.getRoomData().id == roomId)
@@ -1373,7 +1373,7 @@ void ChatServer::disconnectPlayer(const NetworkId & id)
 		instance().chatAvatars.erase(f);
 	}
 
-	std::tr1::unordered_map<NetworkId, ConnectionServerConnection *, NetworkId::Hash>::iterator cf = instance().clientMap.find(id);
+	std::unordered_map<NetworkId, ConnectionServerConnection *, NetworkId::Hash>::iterator cf = instance().clientMap.find(id);
 	if(cf != instance().clientMap.end())
 	{
 		instance().clientMap.erase(cf);
@@ -2268,7 +2268,7 @@ void ChatServer::sendRoomMessage(const ChatAvatarId &id, const std::string & roo
 		}
 		// get room id
 		std::string lowerName = toLower(roomName);
-		std::tr1::unordered_map<std::string, ChatServerRoomOwner>::const_iterator f = instance().chatInterface->getRoomList().find(lowerName);
+		std::unordered_map<std::string, ChatServerRoomOwner>::const_iterator f = instance().chatInterface->getRoomList().find(lowerName);
 		if(f != instance().chatInterface->getRoomList().end())
 		{
 			const ChatAvatar *sender = instance().ownerSystem;
@@ -2386,7 +2386,7 @@ void ChatServer::sendStandardRoomMessage(const ChatAvatarId &senderId, const std
 			return;
 		}
 	
-		std::tr1::unordered_map<std::string, ChatServerRoomOwner>::const_iterator f = instance().chatInterface->getRoomList().find(lowerName);
+		std::unordered_map<std::string, ChatServerRoomOwner>::const_iterator f = instance().chatInterface->getRoomList().find(lowerName);
 		if(f != instance().chatInterface->getRoomList().end())
 		{
 			const ChatAvatar *sender;
@@ -2457,13 +2457,13 @@ void ChatServer::removeConnectionServerConnection(ConnectionServerConnection * t
 {
 	ChatServer::fileLog(false, "ChatServer", "removeConnectionServerConnection() target(%s)", getConnectionAddress(target).c_str());
 
-	std::tr1::unordered_map<NetworkId, ConnectionServerConnection *, NetworkId::Hash> tmpList = instance().clientMap;
-	std::tr1::unordered_map<NetworkId, ConnectionServerConnection *, NetworkId::Hash>::const_iterator i;
+	std::unordered_map<NetworkId, ConnectionServerConnection *, NetworkId::Hash> tmpList = instance().clientMap;
+	std::unordered_map<NetworkId, ConnectionServerConnection *, NetworkId::Hash>::const_iterator i;
 	for(i = tmpList.begin(); i != tmpList.end(); ++i)
 	{
 		if((*i).second == target)
 			disconnectPlayer((*i).first);
-		std::tr1::unordered_map<NetworkId, ConnectionServerConnection *, NetworkId::Hash>::iterator f = instance().clientMap.find((*i).first);
+		std::unordered_map<NetworkId, ConnectionServerConnection *, NetworkId::Hash>::iterator f = instance().clientMap.find((*i).first);
 		if (f != instance().clientMap.end())
 		{
 			instance().clientMap.erase(f);
@@ -2913,7 +2913,7 @@ void ChatServer::sendToGameServerById(unsigned const connectionId, GameNetworkMe
 GameServerConnection *ChatServer::getGameServerConnectionFromId(unsigned int sequence)
 {
 	GameServerConnection * result = NULL;
-	std::tr1::unordered_map<unsigned int, GameServerConnection *>::iterator f = m_gameServerConnectionRegistry.find(sequence);
+	std::unordered_map<unsigned int, GameServerConnection *>::iterator f = m_gameServerConnectionRegistry.find(sequence);
 	if(f != m_gameServerConnectionRegistry.end())
 	{
 		result = (*f).second;

engine/server/application/ChatServer/src/shared/ChatServer.h

@@ -11,7 +11,7 @@
 #include "ChatAPI/ChatAPI.h"
 #include "sharedFoundation/NetworkId.h"
 #include "sharedNetworkMessages/ChatAvatarId.h"
-#include <tr1/unordered_map>
+#include <unordered_map>
 #include <map>
 #include <set>
 #include <string>
@@ -111,7 +111,7 @@ public:
 	//-----------------------------------------------------------------------
 
 
-	std::tr1::unordered_map<unsigned, NetworkId>                  pendingRequests;
+	std::unordered_map<unsigned, NetworkId>                  pendingRequests;
 	static ChatServer &  instance                   ();
 
 	static bool        isValidChatAvatarName(Unicode::String const &chatName);
@@ -225,7 +225,7 @@ private:
 		time_t chatSpamNextTimeToNotifyPlayerWhenLimited;
 		time_t unsquelchTime;
 	};
-	typedef std::tr1::unordered_map<NetworkId, AvatarExtendedData, NetworkId::Hash> ChatAvatarList;
+	typedef std::unordered_map<NetworkId, AvatarExtendedData, NetworkId::Hash> ChatAvatarList;
 
 
 	struct VoiceChatAvatarData
@@ -234,7 +234,7 @@ private:
 		std::string playerName;
 	};
 
-	typedef std::tr1::unordered_map<NetworkId, VoiceChatAvatarData, NetworkId::Hash> VoiceChatAvatarList;
+	typedef std::unordered_map<NetworkId, VoiceChatAvatarData, NetworkId::Hash> VoiceChatAvatarList;
 
 	static AvatarExtendedData * getAvatarExtendedDataByNetworkId(const NetworkId & id);
 
@@ -243,8 +243,8 @@ private:
 	ChatAvatarList                                                    chatAvatars;
 	ChatInterface *                                                   chatInterface;
 	VChatInterface *                                                  voiceChatInterface;
-	std::tr1::unordered_map<NetworkId, ConnectionServerConnection *, NetworkId::Hash>  clientMap;
-	std::tr1::unordered_map<unsigned int, GameServerConnection *>                      gameServerConnectionMap;
+	std::unordered_map<NetworkId, ConnectionServerConnection *, NetworkId::Hash>  clientMap;
+	std::unordered_map<unsigned int, GameServerConnection *>                      gameServerConnectionMap;
 	std::set<ConnectionServerConnection *>              connectionServerConnections;
 	
 	bool                             done;
@@ -255,7 +255,7 @@ private:
 	static ChatServer *              m_instance;
 	CustomerServiceServerConnection *customerServiceServerConnection;
 
-	typedef std::tr1::unordered_map<unsigned int, GameServerConnection *> GameServerMap;
+	typedef std::unordered_map<unsigned int, GameServerConnection *> GameServerMap;
 	GameServerMap m_gameServerConnectionRegistry;
 	VoiceChatAvatarList m_voiceChatIdMap;
 	std::map<std::string, NetworkId> m_voiceChatNameToIdMap;

engine/server/application/ChatServer/src/shared/FirstChatServer.h

@@ -27,7 +27,7 @@ namespace Archive
 #include "sharedFoundation/NetworkId.h"
 #include "sharedNetwork/Connection.h"
 #include "ChatAPI/ChatAPI.h"
-#include <tr1/unordered_map>
+#include <unordered_map>
 #include <string>
 
 //-----------------------------------------------------------------------

engine/server/application/ConnectionServer/src/shared/ClientConnection.cpp

@@ -395,7 +395,7 @@ void ClientConnection::handleClientIdMessage(const ClientIdMsg& msg)
 			m_suid = atoi(m_accountName.c_str());
 			if (m_suid == 0)
 			{
-				std::tr1::hash<std::string> h;
+				std::hash<std::string> h;
 				m_suid = h(m_accountName.c_str());
 			}
 			onValidateClient(m_suid, m_accountName, m_isSecure, NULL, ConfigConnectionServer::getDefaultGameFeatures(), ConfigConnectionServer::getDefaultSubscriptionFeatures(), 0, 0, 0, 0, ConfigConnectionServer::getFakeBuddyPoints());

engine/server/application/ConnectionServer/src/shared/ConnectionServer.h

@@ -6,7 +6,7 @@
 
 //-----------------------------------------------------------------------
 
-#include <tr1/unordered_map>
+#include <unordered_map>
 #include <set>
 #include <string>
 
@@ -40,9 +40,9 @@ class ConnectionServer : public MessageDispatch::Receiver
 
 	~ConnectionServer ();
 		
-	typedef std::tr1::unordered_map<uint32, GameConnection *>              GameServerMap;
-	typedef std::tr1::unordered_map<NetworkId, Client *,NetworkId::Hash>   ClientMap;
-	typedef std::tr1::unordered_map<uint32, ClientConnection *>            SuidMap;
+	typedef std::unordered_map<uint32, GameConnection *>              GameServerMap;
+	typedef std::unordered_map<NetworkId, Client *,NetworkId::Hash>   ClientMap;
+	typedef std::unordered_map<uint32, ClientConnection *>            SuidMap;
 	typedef std::set<uint32>                                     FreeTrialsSet;
 	
 	static void                   addNewClient(ClientConnection* cconn, const NetworkId &oid, GameConnection* gconn, const std::string &sceneName, bool sendToStarport );

engine/server/application/CustomerServiceServer/src/linux/main.cpp

@@ -12,7 +12,7 @@
 #include "sharedNetworkMessages/SetupSharedNetworkMessages.h"
 #include "sharedRandom/SetupSharedRandom.h"
 #include "sharedThread/SetupSharedThread.h"
-#include <tr1/unordered_map>
+#include <unordered_map>
 
 // ======================================================================
 

engine/server/application/CustomerServiceServer/src/shared/FirstCustomerServiceServer.h

@@ -12,7 +12,7 @@
 #include "sharedFoundation/FirstSharedFoundation.h"
 #include "sharedFoundation/NetworkId.h"
 #include "sharedNetwork/Connection.h"
-#include <tr1/unordered_map>
+#include <unordered_map>
 #include <string>
 
 //-----------------------------------------------------------------------

engine/server/application/LoginServer/src/shared/ClientConnection.cpp

@@ -196,7 +196,7 @@ void ClientConnection::validateClient(const std::string & id, const std::string
 
 		if (suid==0)
 		{
-			std::tr1::hash<std::string> h;
+			std::hash<std::string> h;
 			suid = h(id); //lint !e603 // Symbol 'h' not initialized (it's a functor)
 		}
 		

engine/server/application/LoginServer/src/shared/LoginServer.h

@@ -12,7 +12,7 @@
 #include "sharedFoundation/StationId.h"
 #include "sharedMessageDispatch/Receiver.h"
 #include "sharedNetwork/Service.h"
-#include <tr1/unordered_map>
+#include <unordered_map>
 #include <map>
 #include <string>
 
@@ -43,7 +43,7 @@ public:
 	ClientConnection*        getUnvalidatedClient (int clientId);
 	void                     removeClient        (int clientId);
 		
-	const std::tr1::unordered_map<std::string, const CentralServerConnection *> & getCentralServerMap_hide() const;
+	const std::unordered_map<std::string, const CentralServerConnection *> & getCentralServerMap_hide() const;
 
 	bool                     deleteCharacter     (uint32 clusterId, NetworkId const & characterId, StationId suid);
 

engine/server/application/PlanetServer/src/shared/Scene.h

@@ -10,8 +10,8 @@
 
 // ======================================================================
 
-#include <tr1/unordered_map>
-#include <tr1/unordered_set>
+#include <unordered_map>
+#include <unordered_set>
 #include <string>
 #include <set>
 
@@ -93,9 +93,9 @@ class Scene : public Singleton2<Scene>, public MessageDispatch::Receiver
 		Coordinates();
 	};
 
-	typedef std::tr1::unordered_map<NetworkId, PlanetProxyObject*, NetworkId::Hash>  ObjectMapType;
-	typedef std::tr1::unordered_set<NetworkId, NetworkId::Hash>                      DeletedSetType;
-	typedef std::tr1::unordered_map<Coordinates, Node*, Coordinates::Hasher>         NodeMapType;
+	typedef std::unordered_map<NetworkId, PlanetProxyObject*, NetworkId::Hash>  ObjectMapType;
+	typedef std::unordered_set<NetworkId, NetworkId::Hash>                      DeletedSetType;
+	typedef std::unordered_map<Coordinates, Node*, Coordinates::Hasher>         NodeMapType;
 	
   private:
 	std::string       m_sceneId;

engine/server/library/serverDatabase/src/shared/DatabaseProcess.cpp

@@ -369,7 +369,7 @@ void DatabaseProcess::connectToGameServer(const char *address, uint16 port, uint
 	if(i == pendingGameServerConnections.end())
 	{		
 		// check to see if there is already a connection active
-		std::tr1::unordered_map<uint32, GameServerConnection *>::const_iterator j = gameServerConnections.find(processId);
+		std::unordered_map<uint32, GameServerConnection *>::const_iterator j = gameServerConnections.find(processId);
 		if(j == gameServerConnections.end())
 		{
 			// make the connection
@@ -383,7 +383,7 @@ void DatabaseProcess::connectToGameServer(const char *address, uint16 port, uint
 GameServerConnection * DatabaseProcess::getConnectionByProcess(const uint32 processId)
 {
 	GameServerConnection * result = 0;
-	std::tr1::unordered_map<uint32, GameServerConnection *>::const_iterator j = gameServerConnections.find(processId);
+	std::unordered_map<uint32, GameServerConnection *>::const_iterator j = gameServerConnections.find(processId);
 	if(j != gameServerConnections.end())
 	{
 		result = (*j).second;
@@ -395,7 +395,7 @@ GameServerConnection * DatabaseProcess::getConnectionByProcess(const uint32 proc
 
 void DatabaseProcess::getGameServerProcessIds(std::vector<uint32> &processIds) const
 {
-	for (std::tr1::unordered_map<uint32, GameServerConnection *>::const_iterator i = gameServerConnections.begin(); i != gameServerConnections.end(); ++i)
+	for (std::unordered_map<uint32, GameServerConnection *>::const_iterator i = gameServerConnections.begin(); i != gameServerConnections.end(); ++i)
 		processIds.push_back((*i).first);
 }
 
@@ -637,7 +637,7 @@ void DatabaseProcess::sendToCommoditiesServer(GameNetworkMessage const &message,
 
 void DatabaseProcess::sendToAllGameServers(GameNetworkMessage const &message, bool reliable)
 {
-	for (std::tr1::unordered_map<uint32, GameServerConnection *>::const_iterator i=gameServerConnections.begin(); i!=gameServerConnections.end(); ++i)
+	for (std::unordered_map<uint32, GameServerConnection *>::const_iterator i=gameServerConnections.begin(); i!=gameServerConnections.end(); ++i)
 		i->second->send(message,reliable);
 }
 
@@ -645,7 +645,7 @@ void DatabaseProcess::sendToAllGameServers(GameNetworkMessage const &message, bo
 
 void DatabaseProcess::sendToGameServer(uint32 serverId, GameNetworkMessage const &message)
 {
-	std::tr1::unordered_map<uint32, GameServerConnection *>::const_iterator i=gameServerConnections.find(serverId);
+	std::unordered_map<uint32, GameServerConnection *>::const_iterator i=gameServerConnections.find(serverId);
 	if (i!=gameServerConnections.end())
 		i->second->send(message,true);
 	else

engine/server/library/serverDatabase/src/shared/DatabaseProcess.h

@@ -10,7 +10,7 @@
 
 // ======================================================================
 
-#include <tr1/unordered_map>
+#include <unordered_map>
 #include <set>
 #include <string>
 #include "sharedFoundation/NetworkIdArchive.h"
@@ -88,7 +88,7 @@ class DatabaseProcess : public MessageDispatch::Receiver
 	CommoditiesServerConnection * commoditiesConnection;
 	DatabaseMetricsData *         m_metricsData;
 	
-	std::tr1::unordered_map<uint32, GameServerConnection *>     gameServerConnections;
+	std::unordered_map<uint32, GameServerConnection *>     gameServerConnections;
 	std::set<std::pair<std::string, unsigned short> > pendingGameServerConnections;
 
 	int m_queryExecCount;

engine/server/library/serverDatabase/src/shared/Persister.h

@@ -12,7 +12,7 @@
 
 #include <map>
 #include <string>
-#include <tr1/unordered_map>
+#include <unordered_map>
 #include <vector>
 #include <set> //TODO: remove when we clean up newCharacterLock hack
 
@@ -105,7 +105,7 @@ class Persister : public MessageDispatch::Receiver
 	};
 
 	typedef std::map<uint32,Snapshot*>            ServerSnapshotMap;
-	typedef std::tr1::unordered_map<NetworkId,Snapshot*>    ObjectSnapshotMap; 
+	typedef std::unordered_map<NetworkId,Snapshot*>    ObjectSnapshotMap; 
 	typedef std::map<NetworkId,PendingCharacter>  PendingCharactersType;
 	typedef std::vector<Snapshot*>                SnapshotListType;
 	typedef std::set<uint32>                      NewCharacterLockType;

engine/server/library/serverGame/src/shared/ai/AiMovementSwarm.cpp

@@ -18,15 +18,15 @@
 #include "sharedLog/Log.h"
 #include "sharedObject/World.h"
 
-#include <tr1/unordered_map>
+#include <unordered_map>
 
 
 using namespace Scripting;
 
 namespace AiMovementSwarmNamespace
 {
-	typedef std::tr1::unordered_map<CachedNetworkId, std::vector<AiMovementSwarm::CreatureWatcher>, CachedNetworkId> targetMap;
-	typedef std::tr1::unordered_map<CachedNetworkId, Vector, CachedNetworkId> offsetMap;
+	typedef std::unordered_map<CachedNetworkId, std::vector<AiMovementSwarm::CreatureWatcher>, CachedNetworkId> targetMap;
+	typedef std::unordered_map<CachedNetworkId, Vector, CachedNetworkId> offsetMap;
 
 	// map of swarm targets to the creatures swarming them
 	targetMap s_swarmMap;

engine/server/library/serverGame/src/shared/commoditiesMarket/CommoditiesMarket.cpp

@@ -590,8 +590,8 @@ static time_t                                          s_timeMarketConnectionCre
 static std::map<int, std::pair<CachedNetworkId, int> > s_queries;
 static std::map<NetworkId, QueuedQuery *>              s_queryTime;
 static int                                             s_nextRequestId;
-static std::tr1::unordered_map<NetworkId, ItemLoadPair, NetworkId::Hash>                  s_pendingLoads;
-static std::tr1::unordered_map<int, int>                         s_pendingAdds; //sequence to cost map
+static std::unordered_map<NetworkId, ItemLoadPair, NetworkId::Hash>                  s_pendingLoads;
+static std::unordered_map<int, int>                         s_pendingAdds; //sequence to cost map
 
 // all money transactions transfer money out of or to the bank of the player and never to or from the vendor/bazaar location except bazaar sale fees
 static const std::string COMMODITIES_NAMED_ACCOUNT("commodities_named_escrow_account");
@@ -1321,7 +1321,7 @@ void CommoditiesMarket::onAddAuction(int sequence, int32 result, const NetworkId
 				}
 			}
 		}
-		std::tr1::unordered_map<int, int>::iterator f = s_pendingAdds.find(sequence);
+		std::unordered_map<int, int>::iterator f = s_pendingAdds.find(sequence);
 		int auctionFee = 0;
 		if (f != s_pendingAdds.end())
 		{
@@ -2488,7 +2488,7 @@ void CommoditiesMarket::checkPendingLoads(const NetworkId &itemId)
 	if (!ConfigServerGame::getCommoditiesMarketEnabled())
 		return;
 	LOG("AuctionRetrieval", ("CommoditiesMarket::response from DB for loading object %s for retrieval", itemId.getValueString().c_str()));
-	std::tr1::unordered_map<NetworkId, ItemLoadPair, NetworkId::Hash>::iterator f = s_pendingLoads.find(itemId);
+	std::unordered_map<NetworkId, ItemLoadPair, NetworkId::Hash>::iterator f = s_pendingLoads.find(itemId);
 	if (f != s_pendingLoads.end())
 	{
 		CreatureObject *player = dynamic_cast<CreatureObject *>(NetworkIdManager::getObjectById((*f).second.ownerId));

engine/server/library/serverGame/src/shared/console/ConsoleCommandParserDefault.h

@@ -10,7 +10,7 @@
 
 #include "sharedCommandParser/CommandParser.h"
 #include <map>
-#include <tr1/unordered_set>
+#include <unordered_set>
 #include "UnicodeUtils.h"
 
 // ======================================================================
@@ -18,7 +18,7 @@ class ConsoleCommandParserDefault : public CommandParser
 {
 public:
 	typedef std::map<String_t, String_t> AliasMap_t;
-	typedef std::tr1::unordered_set<String_t>      AliasGuardSet_t;
+	typedef std::unordered_set<String_t>      AliasGuardSet_t;
 
 
 	explicit               ConsoleCommandParserDefault (void);

engine/server/library/serverGame/src/shared/core/CharacterMatchManager.cpp

@@ -33,7 +33,7 @@
 #include "sharedObject/NetworkIdManager.h"
 #include "sharedSkillSystem/SkillManager.h"
 #include "sharedSkillSystem/SkillObject.h"
-#include <tr1/unordered_map>
+#include <unordered_map>
 #include <limits>
 #include <map>
 #include <vector>

engine/server/library/serverGame/src/shared/core/Client.h

@@ -19,7 +19,7 @@
 #include "sharedObject/CachedNetworkId.h"
 #include "sharedObject/Object.h"
 #include "unicodeArchive/UnicodeArchive.h"
-#include <tr1/unordered_set>
+#include <unordered_set>
 #include <map>
 
 class ConnectionServerConnection;
@@ -128,12 +128,12 @@ public:
 			return (reinterpret_cast<const size_t>(ptr) >> 4);
 		};
 	};
-	typedef std::tr1::unordered_set<ServerObject*, ServerObjectPointerHash> ObservingList;
+	typedef std::unordered_set<ServerObject*, ServerObjectPointerHash> ObservingList;
 
 	// objects being observed that are in this list needs
 	// to have their pvp status updated when there are changes
 	// that requires pvp status to be recalcuclated
-	typedef std::tr1::unordered_set<TangibleObject*, TangibleObjectPointerHash> ObservingListPvpSync;
+	typedef std::unordered_set<TangibleObject*, TangibleObjectPointerHash> ObservingListPvpSync;
 
 	ObservingList const &          getObserving() const;
 	ObservingListPvpSync const &   getObservingPvpSync() const;

engine/server/library/serverGame/src/shared/core/LogoutTracker.cpp

@@ -25,14 +25,14 @@
 #include "sharedObject/Container.h"
 #include <queue>
 #include <map>
-#include <tr1/unordered_map>
+#include <unordered_map>
 
 // ======================================================================
 
 static bool s_installed;
 static Scheduler *s_logoutTrackerScheduler;
 static std::queue<NetworkId> s_logoutCallbacks;
-static std::tr1::unordered_map<NetworkId, int, NetworkId::Hash> s_logoutCallbacksCount;
+static std::unordered_map<NetworkId, int, NetworkId::Hash> s_logoutCallbacksCount;
 
 namespace LogoutTrackerNamespace
 {
@@ -76,7 +76,7 @@ void LogoutTracker::add(NetworkId const &networkId)
 	// when they go off, and only when the last 3 minute timer goes off do we remove him from the
 	// world, which is the desired behavior of leaving a disconnected character in the world for
 	// 3 minutes before removing him from the world
-	std::tr1::unordered_map<NetworkId, int, NetworkId::Hash>::iterator iter = s_logoutCallbacksCount.find(networkId);
+	std::unordered_map<NetworkId, int, NetworkId::Hash>::iterator iter = s_logoutCallbacksCount.find(networkId);
 	if (iter == s_logoutCallbacksCount.end())
 	{
 		s_logoutCallbacksCount[networkId] = 1;
@@ -97,7 +97,7 @@ void LogoutTracker::handleLogoutCallback(const void *context)
 	UNREF(context);
 
 	NetworkId const &networkId = s_logoutCallbacks.front();
-	std::tr1::unordered_map<NetworkId, int, NetworkId::Hash>::iterator iter = s_logoutCallbacksCount.find(networkId);
+	std::unordered_map<NetworkId, int, NetworkId::Hash>::iterator iter = s_logoutCallbacksCount.find(networkId);
 
 	// only process the *LAST* logout callback that is put into the logout callback
 	// queue for this object as the previous ones are no longer applicable

engine/server/library/serverGame/src/shared/guild/GuildInterface.cpp

@@ -23,7 +23,7 @@
 #include "sharedFoundation/FormattedString.h"
 #include "sharedNetworkMessages/ChatRoomData.h"
 
-#include <tr1/unordered_map>
+#include <unordered_map>
 
 // ======================================================================
 

engine/server/library/serverGame/src/shared/object/CreatureObject.cpp

@@ -183,7 +183,7 @@
 #include <algorithm>
 #include <deque>
 #include <limits>
-#include <tr1/unordered_set>
+#include <unordered_set>
 #include <set>
 
 //----------------------------------------------------------------------

engine/server/library/serverGame/src/shared/object/ServerObject.cpp

@@ -8393,11 +8393,11 @@ void ServerObject::stopListeningToAllBroadcastMessages()
 	else
 	{
 		// build list of all broadcasters this object is currently listening to
-		std::tr1::unordered_set<NetworkId> broadcasters;
+		std::unordered_set<NetworkId> broadcasters;
 		for (BroadcastMap::const_iterator iter = m_broadcastBroadcasters.begin(); iter != m_broadcastBroadcasters.end(); ++iter)
 			IGNORE_RETURN(broadcasters.insert(iter->second));
 
-		for (std::tr1::unordered_set<NetworkId>::const_iterator iter2 = broadcasters.begin(); iter2 != broadcasters.end(); ++iter2)
+		for (std::unordered_set<NetworkId>::const_iterator iter2 = broadcasters.begin(); iter2 != broadcasters.end(); ++iter2)
 		{
 			// need to send a message to the broadcaster if the broadcaster is not on this game server
 			ServerObject * objBroadcaster = ServerWorld::findObjectByNetworkId(*iter2);

engine/server/library/serverGame/src/shared/object/TriggerVolume.cpp

@@ -18,7 +18,7 @@
 #include "sharedDebug/Profiler.h"
 #include "sharedObject/NetworkIdManager.h"
 #include <algorithm>
-#include <tr1/unordered_map>
+#include <unordered_map>
 
 // ======================================================================
 
@@ -48,8 +48,8 @@ namespace TriggerVolumeNamespace
 		// optimization to track how many time a NetworkId appears
 		// in sources and targets, so that we can avoid unnecessarily
 		// searching the entire sources and targets vectors
-		std::tr1::unordered_map<NetworkId, int> m_sourcesCount;
-		std::tr1::unordered_map<NetworkId, int> m_targetsCount;
+		std::unordered_map<NetworkId, int> m_sourcesCount;
+		std::unordered_map<NetworkId, int> m_targetsCount;
 	};
 
 	// ----------------------------------------------------------------------
@@ -61,7 +61,7 @@ namespace TriggerVolumeNamespace
 		m_sources.push_back(source);
 		m_targets.push_back(target);
 
-		std::tr1::unordered_map<NetworkId, int>::iterator i = m_sourcesCount.find(source);
+		std::unordered_map<NetworkId, int>::iterator i = m_sourcesCount.find(source);
 		if (i == m_sourcesCount.end())
 			m_sourcesCount[source] = 1;
 		else
@@ -80,7 +80,7 @@ namespace TriggerVolumeNamespace
 	{
 		// remove all entries from sources
 		// and targets for the specified id
-		std::tr1::unordered_map<NetworkId, int>::iterator const iterCountSource = m_sourcesCount.find(id);
+		std::unordered_map<NetworkId, int>::iterator const iterCountSource = m_sourcesCount.find(id);
 		if (iterCountSource != m_sourcesCount.end())
 		{
 			int countSource = iterCountSource->second;
@@ -104,7 +104,7 @@ namespace TriggerVolumeNamespace
 					std::vector<NetworkId>::iterator targetsIter = m_targets.begin();
 					std::advance(targetsIter, index);
 
-					std::tr1::unordered_map<NetworkId, int>::iterator const iterCountTarget = m_targetsCount.find(*targetsIter);
+					std::unordered_map<NetworkId, int>::iterator const iterCountTarget = m_targetsCount.find(*targetsIter);
 					if (iterCountTarget != m_targetsCount.end())
 					{
 						if (iterCountTarget->second <= 1)
@@ -128,7 +128,7 @@ namespace TriggerVolumeNamespace
 			m_sourcesCount.erase(iterCountSource);
 		}
 
-		std::tr1::unordered_map<NetworkId, int>::iterator const iterCountTarget = m_targetsCount.find(id);
+		std::unordered_map<NetworkId, int>::iterator const iterCountTarget = m_targetsCount.find(id);
 		if (iterCountTarget != m_targetsCount.end())
 		{
 			int countTarget = iterCountTarget->second;
@@ -152,7 +152,7 @@ namespace TriggerVolumeNamespace
 					std::vector<NetworkId>::iterator sourcesIter = m_sources.begin();
 					std::advance(sourcesIter, index);
 
-					std::tr1::unordered_map<NetworkId, int>::iterator const iterCountSource = m_sourcesCount.find(*sourcesIter);
+					std::unordered_map<NetworkId, int>::iterator const iterCountSource = m_sourcesCount.find(*sourcesIter);
 					if (iterCountSource != m_sourcesCount.end())
 					{
 						if (iterCountSource->second <= 1)

engine/server/library/serverGame/src/shared/object/TriggerVolume.h

@@ -14,7 +14,7 @@
 #include "sharedFoundation/NetworkId.h"
 #include "sharedUtility/PooledString.h"
 
-#include <tr1/unordered_set>
+#include <unordered_set>
 
 // ======================================================================
 
@@ -40,7 +40,7 @@ public:
 		};
 	};
 
-	typedef std::tr1::unordered_set<ServerObject *, ServerObjectPointerHash> ContentsSet;
+	typedef std::unordered_set<ServerObject *, ServerObjectPointerHash> ContentsSet;
 
 	void                              addObject(ServerObject &object);
 	void                              addEventSource(NetworkId const &source);

engine/server/library/serverGame/src/shared/objectTemplate/ServerObjectTemplate.cpp

@@ -21,7 +21,7 @@
 //@END TFD TEMPLATE REFS
 #include <stdio.h>
 
-#include <tr1/unordered_map>
+#include <unordered_map>
 
 const std::string DefaultString("");
 const StringId DefaultStringId("", 0);
@@ -30,7 +30,7 @@ const TriggerVolumeData DefaultTriggerVolumeData;
 
 bool ServerObjectTemplate::ms_allowDefaultTemplateParams = true;
 
-typedef std::tr1::unordered_map<ServerObjectTemplate::XpTypes, std::string, std::tr1::hash<int> > XP_MAP; 
+typedef std::unordered_map<ServerObjectTemplate::XpTypes, std::string, std::hash<int> > XP_MAP; 
 static XP_MAP * XpMap = NULL;
 
 

engine/server/library/serverGame/src/shared/pvp/PvpUpdateObserver.cpp

@@ -18,8 +18,8 @@
 #include "sharedLog/Log.h"
 #include "sharedNetworkMessages/UpdatePvpStatusMessage.h"
 
-#include <tr1/unordered_map>
-#include <tr1/unordered_set>
+#include <unordered_map>
+#include <unordered_set>
 
 // ======================================================================
 
@@ -41,12 +41,12 @@ namespace PvpUpdateObserverNamespace
 		};
 	};
 
-	std::tr1::unordered_set<TangibleObject const *, TangibleObjectPointerHash> s_activeUpdaters;
+	std::unordered_set<TangibleObject const *, TangibleObjectPointerHash> s_activeUpdaters;
 
-	typedef std::tr1::unordered_map<Client const *, std::tr1::unordered_map<NetworkId, std::pair<uint32, uint32> >, ClientObjectPointerHash> PvpUpdateObserverCache;
+	typedef std::unordered_map<Client const *, std::unordered_map<NetworkId, std::pair<uint32, uint32> >, ClientObjectPointerHash> PvpUpdateObserverCache;
 	PvpUpdateObserverCache s_pvpUpdateObserverCache;
 
-	typedef std::tr1::unordered_map<Client const *, std::tr1::unordered_set<NetworkId>, ClientObjectPointerHash> PvpUpdateObserverRequestsThisFrame;
+	typedef std::unordered_map<Client const *, std::unordered_set<NetworkId>, ClientObjectPointerHash> PvpUpdateObserverRequestsThisFrame;
 	PvpUpdateObserverRequestsThisFrame s_pvpUpdateObserverRequestsThisFrame;
 
 	// PvpUpdateObserver can be called multiple times per frame for the same object,
@@ -57,10 +57,10 @@ namespace PvpUpdateObserverNamespace
 	// so as an optimization, we'll only iterate over these 2 lists once per frame,
 	// and then just watch on individual updates to these 2 lists afterwards, and
 	// process the individual updates to these 2 lists when the updates occur
-	std::tr1::unordered_set<NetworkId> s_objectsProcessedThisFrame;
-	std::tr1::unordered_set<Client const *, ClientObjectPointerHash> s_clientsProcessedThisFrame;
+	std::unordered_set<NetworkId> s_objectsProcessedThisFrame;
+	std::unordered_set<Client const *, ClientObjectPointerHash> s_clientsProcessedThisFrame;
 
-	void sendUpdatePvpStatusMessage(Client const & client, std::tr1::unordered_set<NetworkId> const & requestedNetworkId, std::tr1::unordered_map<NetworkId, std::pair<uint32, uint32> > & cachedNetworkId);
+	void sendUpdatePvpStatusMessage(Client const & client, std::unordered_set<NetworkId> const & requestedNetworkId, std::unordered_map<NetworkId, std::pair<uint32, uint32> > & cachedNetworkId);
 }
 
 using namespace PvpUpdateObserverNamespace;
@@ -86,7 +86,7 @@ PvpUpdateObserver::PvpUpdateObserver(TangibleObject const *who, Archive::AutoDel
 		std::set<Client *> const &clients = who->getObservers();
 		for (std::set<Client *>::const_iterator i = clients.begin(); i != clients.end(); ++i)
 		{
-			std::tr1::unordered_map<NetworkId, std::pair<uint32, uint32> > & pvpUpdateObserverCache = s_pvpUpdateObserverCache[*i];
+			std::unordered_map<NetworkId, std::pair<uint32, uint32> > & pvpUpdateObserverCache = s_pvpUpdateObserverCache[*i];
 			if (pvpUpdateObserverCache.count(who->getNetworkId()) == 0)
 			{
 				uint32 flags, factionId;
@@ -104,8 +104,8 @@ PvpUpdateObserver::PvpUpdateObserver(TangibleObject const *who, Archive::AutoDel
 		Client * const client = who->getClient();
 		if (client && (s_clientsProcessedThisFrame.count(client) == 0))
 		{
-			std::tr1::unordered_map<NetworkId, std::pair<uint32, uint32> > & pvpUpdateObserverCache = s_pvpUpdateObserverCache[client];
-			std::tr1::unordered_set<NetworkId> & pvpUpdateObserverRequestsThisFrame = s_pvpUpdateObserverRequestsThisFrame[client];
+			std::unordered_map<NetworkId, std::pair<uint32, uint32> > & pvpUpdateObserverCache = s_pvpUpdateObserverCache[client];
+			std::unordered_set<NetworkId> & pvpUpdateObserverRequestsThisFrame = s_pvpUpdateObserverRequestsThisFrame[client];
 
 			Client::ObservingListPvpSync const &objs = client->getObservingPvpSync();
 			for (Client::ObservingListPvpSync::const_iterator i = objs.begin(); i != objs.end(); ++i)
@@ -218,7 +218,7 @@ void PvpUpdateObserver::startObservingPvpSyncNotification(Client const *client,
 
 	if ((s_objectsProcessedThisFrame.count(who.getNetworkId()) != 0) || (s_clientsProcessedThisFrame.count(client) != 0))
 	{
-		std::tr1::unordered_map<NetworkId, std::pair<uint32, uint32> > & pvpUpdateObserverCache = s_pvpUpdateObserverCache[client];
+		std::unordered_map<NetworkId, std::pair<uint32, uint32> > & pvpUpdateObserverCache = s_pvpUpdateObserverCache[client];
 		if (pvpUpdateObserverCache.count(who.getNetworkId()) == 0)
 		{
 			uint32 flags, factionId;
@@ -274,14 +274,14 @@ void PvpUpdateObserver::update()
 
 // ----------------------------------------------------------------------
 
-void PvpUpdateObserverNamespace::sendUpdatePvpStatusMessage(Client const & client, std::tr1::unordered_set<NetworkId> const & requestedNetworkId, std::tr1::unordered_map<NetworkId, std::pair<uint32, uint32> > & cachedNetworkId)
+void PvpUpdateObserverNamespace::sendUpdatePvpStatusMessage(Client const & client, std::unordered_set<NetworkId> const & requestedNetworkId, std::unordered_map<NetworkId, std::pair<uint32, uint32> > & cachedNetworkId)
 {
 	uint32 flags, factionId;
 	ServerObject const * serverObject;
 	TangibleObject const * tangibleObject;
-	std::tr1::unordered_map<NetworkId, std::pair<uint32, uint32> >::iterator iterCacheNetworkId;
+	std::unordered_map<NetworkId, std::pair<uint32, uint32> >::iterator iterCacheNetworkId;
 
-	for (std::tr1::unordered_set<NetworkId>::const_iterator iterRequestedNetworkId = requestedNetworkId.begin(); iterRequestedNetworkId != requestedNetworkId.end(); ++iterRequestedNetworkId)
+	for (std::unordered_set<NetworkId>::const_iterator iterRequestedNetworkId = requestedNetworkId.begin(); iterRequestedNetworkId != requestedNetworkId.end(); ++iterRequestedNetworkId)
 	{
 		iterCacheNetworkId = cachedNetworkId.find(*iterRequestedNetworkId);
 		if (iterCacheNetworkId == cachedNetworkId.end())

engine/server/library/serverGame/src/shared/space/SpaceVisibilityManager.cpp

@@ -16,7 +16,7 @@
 #include "sharedObject/NetworkIdManager.h"
 
 #include <algorithm>
-#include <tr1/unordered_map>
+#include <unordered_map>
 
 // ======================================================================
 
@@ -37,7 +37,7 @@ namespace SpaceVisibilityManager_namespace
 	typedef std::set<Client*>                            ClientSet;
 	typedef std::set<TrackedObject*>                     ObjectSet;
 	typedef std::map<Client*, TrackedObject*>            ClientToObjectMapType;
-	typedef std::tr1::unordered_map<NetworkId, TrackedObject*>     TrackedObjectsType;
+	typedef std::unordered_map<NetworkId, TrackedObject*>     TrackedObjectsType;
 
 	// Classes
 

engine/server/library/serverScript/src/shared/ScriptFunctionTable.h

@@ -9,7 +9,7 @@
 #ifndef _INCLUDED_ScriptFuncTable_H
 #define _INCLUDED_ScriptFuncTable_H
 
-#include <tr1/unordered_map>
+#include <unordered_map>
 
 namespace Scripting
 {
@@ -495,7 +495,7 @@ struct ScriptFuncTable
 	const char *argList;
 };
 
-typedef std::tr1::unordered_map< int, const ScriptFuncTable * > _ScriptFuncHashMap;
+typedef std::unordered_map< int, const ScriptFuncTable * > _ScriptFuncHashMap;
 extern _ScriptFuncHashMap *ScriptFuncHashMap;
 extern void InitScriptFuncHashMap(void);
 extern void RemoveScriptFuncHashMap(void);

engine/server/library/serverScript/src/shared/ScriptMethodsPlayerAccount.cpp

@@ -38,7 +38,7 @@
 #include "serverUtility/FreeCtsDataTable.h"
 #include "UnicodeUtils.h"
 
-#include <tr1/unordered_set>
+#include <unordered_set>
 
 using namespace JNIWrappersNamespace;
 
@@ -434,7 +434,7 @@ jboolean JNICALL ScriptMethodsPlayerAccountNamespace::isAccountQualifiedForHouse
 	UNREF(self);
 	NOT_NULL(env);
 
-	static std::tr1::unordered_set<StationId> accountsQualifiedForHousePackup;
+	static std::unordered_set<StationId> accountsQualifiedForHousePackup;
 	if (accountsQualifiedForHousePackup.empty())
 	{
 		DataTable * table = DataTableManager::getTable(ConfigServerGame::getHousePackupAccountListDataTableName(), true);

engine/shared/library/sharedDebug/src/shared/LeakFinder.h

@@ -17,7 +17,7 @@
 
 #include <vector>
 #include <list>
-#include <tr1/unordered_map>
+#include <unordered_map>
 
 // ======================================================================
 
@@ -89,7 +89,7 @@ protected:
 		ReferenceCountingData *referenceData;
 	};
 
-	typedef std::tr1::unordered_map<void *, ObjectData, ptr_hash> ObjectMap;
+	typedef std::unordered_map<void *, ObjectData, ptr_hash> ObjectMap;
 
 	ObjectMap liveObjects;
 };

engine/shared/library/sharedFoundation/src/shared/NetworkId.h

@@ -156,8 +156,6 @@ inline size_t NetworkId::getHashValue () const
 // STL standard hash function
 namespace std
 {
-namespace tr1
-{
 
 template <>
 struct hash<NetworkId>  // stl standard hash
@@ -165,6 +163,6 @@ struct hash<NetworkId>  // stl standard hash
   size_t operator()(const NetworkId &x) const { return x.getHashValue(); }
 };
 
-}}
+}
 
 #endif

engine/shared/library/sharedFoundation/src/shared/StlForwardDeclaration.h

@@ -60,12 +60,8 @@ namespace std
 
 	typedef basic_string<char, char_traits<char>, allocator<char> >                     string;
 
-	namespace tr1
-	{
-		template <class _T1>                                                        struct hash;
-		template <class _Key, class _Tp, class _Hash, class _Compare, class _Alloc> class unordered_map;
-		template <class _Key, class _Hash, class _Compare, class _Alloc> 			class unordered_set;
-	}
+	template <class _Key, class _Tp, class _Hash, class _Compare, class _Alloc> 		class unordered_map;
+	template <class _Key, class _Hash, class _Compare, class _Alloc> 					class unordered_set;
 }
 
 template <class _Tp, class _Alloc = std::allocator<_Tp> > struct stddeque
@@ -88,9 +84,9 @@ template <class _Key, class _Tp, class _Compare = std::less<_Key>, class _Alloc
 //	typedef std::hash_map<_Key, _Tp, _HashFcn, _Compare, _Alloc> fwd;
 //};
 
-template <class _Key, class _Tp, class _HashFcn = std::tr1::hash<_Key>, class _Compare = std::equal_to<_Key>, class _Alloc = std::allocator< std::pair <const _Key, _Tp> > > struct stdunordered_map
+template <class _Key, class _Tp, class _HashFcn = std::hash<_Key>, class _Compare = std::equal_to<_Key>, class _Alloc = std::allocator< std::pair <const _Key, _Tp> > > struct stdunordered_map
 {
-	typedef std::tr1::unordered_map<_Key, _Tp, _HashFcn, _Compare, _Alloc> fwd;
+	typedef std::unordered_map<_Key, _Tp, _HashFcn, _Compare, _Alloc> fwd;
 };
 
 template <class _Key, class _Tp, class _Compare = std::less<_Key>, class _Alloc = std::allocator< std::pair <const _Key, _Tp> > > struct stdmultimap
@@ -108,9 +104,9 @@ template <class _Key, class _Compare = std::less<_Key>, class _Alloc = std::allo
 //	typedef std::hash_set<_Key, _HashFcn, _Compare, _Alloc> fwd;
 //};
 
-template <class _Key, class _HashFcn = std::tr1::hash<_Key>, class _Compare = std::equal_to<_Key>, class _Alloc = std::allocator<_Key> > struct stdunordered_set
+template <class _Key, class _HashFcn = std::hash<_Key>, class _Compare = std::equal_to<_Key>, class _Alloc = std::allocator<_Key> > struct stdunordered_set
 {
-	typedef std::tr1::unordered_set<_Key, _HashFcn, _Compare, _Alloc> fwd;
+	typedef std::unordered_set<_Key, _HashFcn, _Compare, _Alloc> fwd;
 };
 
 template <class _Key, class _Compare = std::less<_Key>, class _Alloc = std::allocator<_Key> > struct stdmultiset

engine/shared/library/sharedGame/src/shared/combat/CombatDataTable.cpp

@@ -15,7 +15,7 @@
 #include <string>
 #include <algorithm>
 #include <cctype>
-#include <tr1/unordered_map>
+#include <unordered_map>
 
 // ======================================================================
 
@@ -25,7 +25,7 @@ namespace CombatDataTableNamespace
 	std::string const cs_columnActionNameCrc("actionNameCrc");
 	int s_actionNameCrcColumn;
 
-	std::tr1::unordered_map<uint32, int> s_commandsWithMinInvisLevelRequired;
+	std::unordered_map<uint32, int> s_commandsWithMinInvisLevelRequired;
 }
 
 using namespace CombatDataTableNamespace;
@@ -402,7 +402,7 @@ int CombatDataTable::getMinInvisLevelRequired(uint32 commandHash)
 	if(commandHash == 0)
 		return -1;
 
-	std::tr1::unordered_map<uint32, int>::const_iterator it = s_commandsWithMinInvisLevelRequired.find(commandHash);
+	std::unordered_map<uint32, int>::const_iterator it = s_commandsWithMinInvisLevelRequired.find(commandHash);
 	if (it != s_commandsWithMinInvisLevelRequired.end())
 		return it->second;
 

engine/shared/library/sharedGame/src/shared/object/Waypoint.cpp

@@ -19,13 +19,13 @@
 #include "sharedMessageDispatch/Transceiver.h"
 #include "unicodeArchive/UnicodeArchive.h"
 #include "UnicodeUtils.h"
-#include <tr1/unordered_map>
+#include <unordered_map>
 
 // ======================================================================
 
 namespace WaypointNamespace
 {
-	typedef std::tr1::unordered_map<NetworkId, WaypointData *> WaypointMapById;
+	typedef std::unordered_map<NetworkId, WaypointData *> WaypointMapById;
 	WaypointMapById s_waypointMapById;
 	bool s_installed;
 
@@ -106,7 +106,7 @@ namespace Archive
 		if (networkId.isValid())
 		{
 			WaypointData *data = 0;
-			std::tr1::unordered_map<NetworkId, WaypointData *>::iterator f = s_waypointMapById.find(networkId);
+			std::unordered_map<NetworkId, WaypointData *>::iterator f = s_waypointMapById.find(networkId);
 			if (f == s_waypointMapById.end())
 				data = new WaypointData(networkId);
 			else
@@ -331,7 +331,7 @@ std::string const &Waypoint::getColorNameById(uint8 id) // static
 Waypoint const Waypoint::getWaypointById(NetworkId const &id) // static
 {
 	Waypoint result;
-	std::tr1::unordered_map<NetworkId, WaypointData *>::iterator f = s_waypointMapById.find(id);
+	std::unordered_map<NetworkId, WaypointData *>::iterator f = s_waypointMapById.find(id);
 	if (f != s_waypointMapById.end())
 		result.releaseData(f->second);
 	return result;

engine/shared/library/sharedGame/src/shared/space/ShipChassisSlotType.cpp

@@ -12,7 +12,7 @@
 
 #include "Unicode.h"
 
-#include <tr1/unordered_map>
+#include <unordered_map>
 
 //======================================================================
 

engine/shared/library/sharedGame/src/shared/space/ShipComponentType.cpp

@@ -8,7 +8,7 @@
 #include "sharedGame/FirstSharedGame.h"
 #include "sharedGame/ShipComponentType.h"
 
-#include <tr1/unordered_map>
+#include <unordered_map>
 
 //======================================================================
 

engine/shared/library/sharedMath/src/shared/PositionVertexIndexer.h

@@ -12,7 +12,7 @@
 
 #include "sharedMath/Vector.h"
 
-#include <tr1/unordered_map>
+#include <unordered_map>
 
 // ======================================================================
 
@@ -42,7 +42,7 @@ private:
 
 private:
 
-	typedef std::tr1::unordered_multimap<uint32 /*crc*/, int /*index*/> VertexIndexMap;
+	typedef std::unordered_multimap<uint32 /*crc*/, int /*index*/> VertexIndexMap;
 
 	VectorVector * m_vertices;
 	VertexIndexMap * m_indexMap;

engine/shared/library/sharedMessageDispatch/src/shared/FirstSharedMessageDispatch.h

@@ -16,7 +16,7 @@
 #include "sharedMessageDispatch/Message.h"
 #include "sharedMessageDispatch/Receiver.h"
 #include <set>
-#include <tr1/unordered_map>
+#include <unordered_map>
 
 // ======================================================================
 

engine/shared/library/sharedMessageDispatch/src/shared/MessageManager.cpp

@@ -7,7 +7,7 @@
 #include "sharedMessageDispatch/Receiver.h"
 
 #include <set>
-#include <tr1/unordered_map>
+#include <unordered_map>
 
 namespace MessageDispatch {
 
@@ -15,8 +15,8 @@ MessageManager MessageManager::ms_instance;
 
 struct MessageManager::Data
 {
-	std::tr1::unordered_map<unsigned long int, std::set<Receiver *> > receivers;
-	std::tr1::unordered_map<unsigned long int, std::set<void (*)(const Emitter &, const MessageBase &)> > staticCallbacks;
+	std::unordered_map<unsigned long int, std::set<Receiver *> > receivers;
+	std::unordered_map<unsigned long int, std::set<void (*)(const Emitter &, const MessageBase &)> > staticCallbacks;
 };
 
 //---------------------------------------------------------------------
@@ -72,7 +72,7 @@ void MessageManager::addReceiver(Receiver & target, const MessageBase & source)
 
 void MessageManager::addReceiver(Receiver & target, const unsigned long int messageType)
 {
-	std::tr1::unordered_map<unsigned long int, std::set<Receiver *> >::iterator i = data->receivers.find(messageType);
+	std::unordered_map<unsigned long int, std::set<Receiver *> >::iterator i = data->receivers.find(messageType);
 	if(i != data->receivers.end())
 	{
 		target.setHasTargets(true);
@@ -92,7 +92,7 @@ void MessageManager::addReceiver(Receiver & target, const unsigned long int mess
 
 void MessageManager::addStaticCallback(void (*callback)(const Emitter &, const MessageBase &), const unsigned long int messageType)
 {
-	std::tr1::unordered_map<unsigned long int, std::set<void (*)(const Emitter &, const MessageBase &)> >::iterator f = data->staticCallbacks.find(messageType);
+	std::unordered_map<unsigned long int, std::set<void (*)(const Emitter &, const MessageBase &)> >::iterator f = data->staticCallbacks.find(messageType);
 	if(f != data->staticCallbacks.end())
 	{
 		std::set<void (*)(const Emitter &, const MessageBase &)> & targets = f->second;
@@ -121,7 +121,7 @@ void MessageManager::addStaticCallback(void (*callback)(const Emitter &, const M
 void MessageManager::emitMessage(const Emitter & emitter, const MessageBase & message) const
 {
 	const unsigned long int messageType = message.getType();
-	std::tr1::unordered_map<unsigned long int, std::set<Receiver *> >::const_iterator i = data->receivers.find(messageType);
+	std::unordered_map<unsigned long int, std::set<Receiver *> >::const_iterator i = data->receivers.find(messageType);
 	if(i != data->receivers.end())
 	{
 		const std::set<Receiver *> targets = (*i).second;
@@ -136,7 +136,7 @@ void MessageManager::emitMessage(const Emitter & emitter, const MessageBase & me
 		}
 	}
 
-	std::tr1::unordered_map<unsigned long int, std::set<void (*)(const Emitter &, const MessageBase &)> >::iterator f = data->staticCallbacks.find(messageType);
+	std::unordered_map<unsigned long int, std::set<void (*)(const Emitter &, const MessageBase &)> >::iterator f = data->staticCallbacks.find(messageType);
 	if(f != data->staticCallbacks.end())
 	{
 		const std::set<void (*)(const Emitter &, const MessageBase &)> targets = f->second;
@@ -160,7 +160,7 @@ void MessageManager::receiverDestroyed(const Receiver & target)
 		return;
 	}
 	// find receiver
-	std::tr1::unordered_map<unsigned long int, std::set<Receiver *> >::iterator i;
+	std::unordered_map<unsigned long int, std::set<Receiver *> >::iterator i;
 	for(i = data->receivers.begin(); i != data->receivers.end(); ++i)
 	{
 		std::set<Receiver *> & targets = (*i).second;
@@ -200,7 +200,7 @@ void MessageManager::removeReceiver(const Receiver & target, const char * const
 
 void MessageManager::removeReceiver(const Receiver & target, const unsigned long int messageType)
 {
-	std::tr1::unordered_map<unsigned long int, std::set<Receiver *> >::iterator i = data->receivers.find(messageType);
+	std::unordered_map<unsigned long int, std::set<Receiver *> >::iterator i = data->receivers.find(messageType);
 	if(i != data->receivers.end())
 	{
 		std::set<Receiver *> & targets = (*i).second;

engine/shared/library/sharedNetwork/src/win32/Address.cpp

@@ -374,7 +374,7 @@ size_t Address::hashFunction() const
 
 	Example:
 	\code
-	typedef std::tr1::unordered_map<Address, Connection *, Address::HashFunction, Address::EqualFunction> AddressMap;
+	typedef std::unordered_map<Address, Connection *, Address::HashFunction, Address::EqualFunction> AddressMap;
 	\endcode
 
 	@return true if the left hand side and right hand side are equal

engine/shared/library/sharedNetworkMessages/src/shared/common/GameNetworkMessage.cpp

@@ -13,7 +13,7 @@
 #include "sharedFoundation/CrcString.h"
 #include "sharedNetworkMessages/NetworkMessageFactory.h"
 #include <algorithm>
-#include <tr1/unordered_map>
+#include <unordered_map>
 
 // ======================================================================
 
@@ -22,7 +22,7 @@ std::string const GameNetworkMessage::NetworkVersionId = "20100225-17:43";
 
 namespace GameNetworkMessageNamespace
 {
-	std::tr1::unordered_map<unsigned long, int>  gs_messageCount;
+	std::unordered_map<unsigned long, int>  gs_messageCount;
 
 	// ----------------------------------------------------------------------
 
@@ -34,7 +34,7 @@ namespace GameNetworkMessageNamespace
 		}
 	};
 
-	std::tr1::unordered_map<unsigned long, std::string> s_messageTypes;
+	std::unordered_map<unsigned long, std::string> s_messageTypes;
 }
 
 using namespace GameNetworkMessageNamespace;
@@ -105,7 +105,7 @@ std::vector<std::pair<std::string, int> > const GameNetworkMessage::getMessageCo
 {
 	std::vector<std::pair<std::string, int> > result;
 
-	for (std::tr1::unordered_map <unsigned long, int>::const_iterator i = gs_messageCount.begin(); i != gs_messageCount.end(); ++i)
+	for (std::unordered_map <unsigned long, int>::const_iterator i = gs_messageCount.begin(); i != gs_messageCount.end(); ++i)
 		result.push_back(std::make_pair(s_messageTypes[(*i).first], (*i).second));
 
 	std::sort(result.begin(), result.end(), SortPair());

engine/shared/library/sharedObject/src/shared/object/NetworkIdManager.cpp

@@ -10,7 +10,7 @@
 #include "sharedFoundation/NetworkId.h"
 #include "sharedObject/Object.h"
 
-#include <tr1/unordered_map>
+#include <unordered_map>
 #include <string>
 
 //-----------------------------------------------------------------------

engine/shared/library/sharedSkillSystem/src/shared/SkillManager.cpp

@@ -15,7 +15,7 @@
 #include "sharedDebug/InstallTimer.h"
 
 #include <algorithm>
-#include <tr1/unordered_map>
+#include <unordered_map>
 #include <string>
 
 SkillManager      *SkillManager::ms_instance = NULL;

engine/shared/library/sharedUtility/src/shared/DataTable.cpp

@@ -13,7 +13,7 @@
 #include "sharedUtility/DataTableCell.h"
 
 #include <map>
-#include <tr1/unordered_map>
+#include <unordered_map>
 
 //----------------------------------------------------------------------------
 

engine/shared/library/sharedUtility/src/shared/DataTable.h

@@ -15,7 +15,7 @@
 
 #include <string>
 #include <vector>
-#include <tr1/unordered_map>
+#include <unordered_map>
 
 class Iff;
 
@@ -84,7 +84,7 @@ private:
 	void buildColumnIndexMap();
 
 	typedef std::vector<const DataTableColumnType *> DataTableColumnTypeVector;
-	typedef std::tr1::unordered_map<std::string /*column name*/, int /*column index*/> ColumnIndexMap;
+	typedef std::unordered_map<std::string /*column name*/, int /*column index*/> ColumnIndexMap;
 
 	int                           m_numRows;
 	int                           m_numCols;

engine/shared/library/sharedUtility/src/shared/WorldSnapshotReaderWriter.cpp

@@ -24,7 +24,7 @@
 #include <algorithm>
 #include <map>
 #include <vector>
-#include <tr1/unordered_map>
+#include <unordered_map>
 
 //===================================================================
 

external/3rd/library/platform/utils/Base/linux/Types.h

@@ -21,9 +21,9 @@ namespace NAMESPACE
 
 namespace Base
 {
-#define INT32_MAX  0x7FFFFFFF
-#define INT32_MIN  0x80000000
-#define UINT32_MAX 0xFFFFFFFF
+//#define INT32_MAX  0x7FFFFFFF
+//#define INT32_MIN  0x80000000
+//#define UINT32_MAX 0xFFFFFFFF
 
 typedef signed   char           int8;
 typedef unsigned char           uint8;

external/3rd/library/soePlatform/ChatAPI/utils/Base/linux/Types.h

@@ -21,9 +21,9 @@ namespace NAMESPACE
 
 namespace Base
 {
-#define INT32_MAX  0x7FFFFFFF
-#define INT32_MIN  0x80000000
-#define UINT32_MAX 0xFFFFFFFF
+//#define INT32_MAX  0x7FFFFFFF
+//#define INT32_MIN  0x80000000
+//#define UINT32_MAX 0xFFFFFFFF
 
 typedef signed   char           int8;
 typedef unsigned char           uint8;

external/ours/library/localization/src/shared/LocalizationManager.h

@@ -18,7 +18,7 @@
 #pragma warning (disable:4786)
 #endif
 
-#include <tr1/unordered_map>
+#include <unordered_map>
 #include "Unicode.h"
 #include "UnicodeUtils.h"
 
@@ -57,8 +57,8 @@ public:
 	                             ~LocalizationManager     ();
 
 	typedef std::pair<time_t, LocalizedStringTable *> TimedStringTable;
-	typedef std::tr1::unordered_map<Unicode::NarrowString, TimedStringTable> StringTableMap_t;
-	typedef std::tr1::unordered_map<Unicode::NarrowString, LocalizationManager *> LocalizationManagerHashMap;
+	typedef std::unordered_map<Unicode::NarrowString, TimedStringTable> StringTableMap_t;
+	typedef std::unordered_map<Unicode::NarrowString, LocalizationManager *> LocalizationManagerHashMap;
 
 	static void                   install                 (AbstractFileFactory * fileFactory, Unicode::UnicodeNarrowStringVector & localeNames, bool debugStrings, DebugBadStringsFunc debugBadStringsFunc = 0, bool displayBadStringIds = true);
 	static void                   remove                  ();

external/ours/library/unicode/src/shared/Unicode.h

@@ -18,7 +18,7 @@
 #endif
 
 #include <string>
-#include <tr1/unordered_map>
+#include <unordered_map>
 
 //-----------------------------------------------------------------
 
@@ -47,7 +47,6 @@ namespace Unicode
 }
 
 namespace std {
-namespace tr1 {
 
 	template<>
 	struct hash<Unicode::String>
@@ -64,7 +63,7 @@ namespace tr1 {
 		}
 	};
 
-}}
+}
 
 //-----------------------------------------------------------------
 

game/server/application/SwgDatabaseServer/src/shared/buffers/IndexedTableBuffer.h

@@ -11,7 +11,7 @@
 
 // ======================================================================
 
-#include <tr1/unordered_map>
+#include <unordered_map>
 #include "serverDatabase/TableBuffer.h"
 
 // ======================================================================
@@ -37,7 +37,7 @@ class IndexedNetworkTableBuffer : public TableBuffer
 	IndexedNetworkTableBuffer(TableBufferMode mode, DB::ModeQuery *query);
 	
   private:
-	typedef std::tr1::unordered_map<int, DB::Row*> IndexType;
+	typedef std::unordered_map<int, DB::Row*> IndexType;
 	/**
 	 * Index to locate rows.
 	 *

game/server/application/SwgDatabaseServer/src/shared/buffers/MarketAuctionsBuffer.h

@@ -13,7 +13,7 @@
 #include "SwgDatabaseServer/CommoditiesQuery.h"
 #include "SwgDatabaseServer/CommoditiesSchema.h"
 #include "serverDatabase/AbstractTableBuffer.h"
-#include <tr1/unordered_map>
+#include <unordered_map>
 #include <string>
 
 // ======================================================================
@@ -47,10 +47,10 @@ private:
 	void                      addRowToIndex          (const NetworkId &itemId, DBSchema::MarketAuctionsRow *row);
 
 private:
-	typedef std::tr1::unordered_map<NetworkId, DBSchema::MarketAuctionsRow*> IndexType;
+	typedef std::unordered_map<NetworkId, DBSchema::MarketAuctionsRow*> IndexType;
 	IndexType m_rows;
 
-	typedef std::tr1::unordered_map<NetworkId, std::vector<std::pair<std::string, Unicode::String> > > AttributesType;
+	typedef std::unordered_map<NetworkId, std::vector<std::pair<std::string, Unicode::String> > > AttributesType;
 	AttributesType m_attributes;
 
 private:
@@ -79,7 +79,7 @@ private:
 	void                      addRowToIndex          (const NetworkId &itemId, DBSchema::MarketAuctionsRowDelete *row);
 
 private:
-	typedef std::tr1::unordered_map<NetworkId, DBSchema::MarketAuctionsRowDelete*> IndexType;
+	typedef std::unordered_map<NetworkId, DBSchema::MarketAuctionsRowDelete*> IndexType;
 	IndexType m_rows;
 
 private:
@@ -108,7 +108,7 @@ private:
 	void                      addRowToIndex          (const NetworkId &itemId, DBSchema::MarketAuctionsRowUpdate *row);
 
 private:
-	typedef std::tr1::unordered_map<NetworkId, DBSchema::MarketAuctionsRowUpdate*> IndexType;
+	typedef std::unordered_map<NetworkId, DBSchema::MarketAuctionsRowUpdate*> IndexType;
 	IndexType m_rows;
 
 private:

game/server/application/SwgDatabaseServer/src/shared/core/ObjvarNameManager.cpp

@@ -10,7 +10,7 @@
 
 #include "SwgDatabaseServer/TaskSaveObjvarNames.h"
 #include "sharedFoundation/ExitChain.h"
-#include <tr1/unordered_map>
+#include <unordered_map>
 #include <string>
 #include <vector>