ilikecats/stk-code_catmod
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Cosmetic changes for coding style.

Browse Source
This commit is contained in:
hiker 2015-10-09 16:47:18 +11:00
parent 42ea2e5819
commit a66af6dc91
3 changed files with 73 additions and 65 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

85
src/online/servers_manager.cpp
View File

@ -18,13 +18,14 @@
#include "online/servers_manager.hpp"
#include <string>
#include <irrString.h>
#include <assert.h>
#include "config/user_config.hpp"
#include "utils/translation.hpp"
#include "utils/time.hpp"
#include <assert.h>
#include <irrString.h>
#include <string>
#define SERVER_REFRESH_INTERVAL 5.0f
namespace Online
@ -37,29 +38,31 @@ namespace Online
manager_singleton = new ServersManager();
return manager_singleton;
}
} // get
// ------------------------------------------------------------------------
void ServersManager::deallocate()
{
delete manager_singleton;
manager_singleton = NULL;
} // deallocate
// ============================================================================
// ========================================================================
ServersManager::ServersManager()
{
m_last_load_time.setAtomic(0.0f);
m_joined_server.setAtomic(NULL);
}
} // ServersManager
// ------------------------------------------------------------------------
ServersManager::~ServersManager()
{
cleanUpServers();
MutexLocker(m_joined_server);
delete m_joined_server.getData();
}
} // ~ServersManager
// ============================================================================
// ------------------------------------------------------------------------
void ServersManager::cleanUpServers()
{
m_sorted_servers.lock();
@ -68,12 +71,12 @@ namespace Online
m_mapped_servers.lock();
m_mapped_servers.getData().clear();
m_mapped_servers.unlock();
}
} // cleanUpServers
// ============================================================================
ServersManager::RefreshRequest * ServersManager::refreshRequest(bool request_now) const
// ------------------------------------------------------------------------
ServersManager::RefreshRequest* ServersManager::refreshRequest(bool request_now) const
{
RefreshRequest * request = NULL;
RefreshRequest* request = NULL;
if(StkTime::getRealTime() - m_last_load_time.getAtomic() > SERVER_REFRESH_INTERVAL)
{
request = new RefreshRequest();
@ -84,9 +87,10 @@ namespace Online
}
return request;
}
} // refreshRequest
void ServersManager::refresh(bool success, const XMLNode * input)
// ------------------------------------------------------------------------
void ServersManager::refresh(bool success, const XMLNode *input)
{
if (!success)
{
@ -94,30 +98,31 @@ namespace Online
return;
}
const XMLNode * servers_xml = input->getNode("servers");
const XMLNode *servers_xml = input->getNode("servers");
cleanUpServers();
for (unsigned int i = 0; i < servers_xml->getNumNodes(); i++)
{
addServer(new Server(*servers_xml->getNode(i)));
}
m_last_load_time.setAtomic((float)StkTime::getRealTime());
}
} // refresh
// ------------------------------------------------------------------------
void ServersManager::RefreshRequest::callback()
{
ServersManager::get()->refresh(isSuccess(), getXMLData());
}
} // callback
// ============================================================================
const Server * ServersManager::getQuickPlay() const
// ------------------------------------------------------------------------
const Server* ServersManager::getQuickPlay() const
{
if(m_sorted_servers.getData().size() > 0)
return getServerBySort(0);
return NULL;
}
} // getQuickPlay
// ============================================================================
// ------------------------------------------------------------------------
void ServersManager::setJoinedServer(uint32_t id)
{
MutexLocker(m_joined_server);
@ -125,18 +130,18 @@ namespace Online
// It's a copy!
m_joined_server.getData() = new Server(*getServerByID(id));
}
} // setJoinedServer
// ============================================================================
// ------------------------------------------------------------------------
void ServersManager::unsetJoinedServer()
{
MutexLocker(m_joined_server);
delete m_joined_server.getData();
m_joined_server.getData() = NULL;
}
} // unsetJoinedServer
// ============================================================================
void ServersManager::addServer(Server * server)
// ------------------------------------------------------------------------
void ServersManager::addServer(Server *server)
{
m_sorted_servers.lock();
m_sorted_servers.getData().push_back(server);
@ -145,40 +150,40 @@ namespace Online
m_mapped_servers.lock();
m_mapped_servers.getData()[server->getServerId()] = server;
m_mapped_servers.unlock();
}
} // addServer
// ============================================================================
// ------------------------------------------------------------------------
int ServersManager::getNumServers () const
{
MutexLocker(m_sorted_servers);
return m_sorted_servers.getData().size();
}
} // getNumServers
// ============================================================================
const Server * ServersManager::getServerBySort (int index) const
// ------------------------------------------------------------------------
const Server* ServersManager::getServerBySort (int index) const
{
MutexLocker(m_sorted_servers);
return m_sorted_servers.getData().get(index);
}
} // getServerBySort
// ============================================================================
const Server * ServersManager::getServerByID (uint32_t id) const
// ------------------------------------------------------------------------
const Server* ServersManager::getServerByID (uint32_t id) const
{
MutexLocker(m_mapped_servers);
return m_mapped_servers.getData().at(id);
}
} // getServerByID
// ============================================================================
Server * ServersManager::getJoinedServer() const
// ------------------------------------------------------------------------
Server* ServersManager::getJoinedServer() const
{
return m_joined_server.getAtomic();
}
} // getJoinedServer
// ============================================================================
// ------------------------------------------------------------------------
void ServersManager::sort(bool sort_desc)
{
MutexLocker(m_sorted_servers);
m_sorted_servers.getData().insertionSort(0, sort_desc);
}
} // sort
} // namespace Online

44
src/online/servers_manager.hpp
View File

@ -19,12 +19,12 @@
#ifndef HEADER_SERVERS_MANAGER_HPP
#define HEADER_SERVERS_MANAGER_HPP
#include "utils/ptr_vector.hpp"
#include "utils/types.hpp"
#include "online/server.hpp"
#include "online/request_manager.hpp"
#include "online/server.hpp"
#include "online/xml_request.hpp"
#include "utils/ptr_vector.hpp"
#include "utils/synchronised.hpp"
#include "utils/types.hpp"
namespace Online
{
@ -35,17 +35,19 @@ namespace Online
class ServersManager
{
public:
// ====================================================================
class RefreshRequest : public XMLRequest
{
virtual void callback ();
public:
RefreshRequest() : XMLRequest() {}
};
}; // RefreshRequest
// ====================================================================
private:
ServersManager();
~ServersManager();
/** Sorted vector of servers */
Synchronised<PtrVector<Server> > m_sorted_servers;
@ -53,29 +55,29 @@ namespace Online
Synchronised<std::map<uint32_t, Server*> > m_mapped_servers;
/** This is a pointer to a copy of the server, the moment it got joined */
Synchronised<Server *> m_joined_server;
Synchronised<Server *> m_joined_server;
Synchronised<float> m_last_load_time;
void refresh(bool success, const XMLNode * input);
void cleanUpServers();
Synchronised<float> m_last_load_time;
void refresh(bool success, const XMLNode * input);
void cleanUpServers();
public:
// Singleton
static ServersManager* get();
static void deallocate();
static ServersManager* get();
static void deallocate();
RefreshRequest * refreshRequest(bool request_now = true) const;
void setJoinedServer(uint32_t server_id);
void unsetJoinedServer();
void addServer(Server * server);
int getNumServers () const;
const Server * getServerByID (uint32_t server_id) const;
const Server * getServerBySort (int index) const;
void sort(bool sort_desc);
Server * getJoinedServer() const;
RefreshRequest * refreshRequest(bool request_now = true) const;
void setJoinedServer(uint32_t server_id);
void unsetJoinedServer();
void addServer(Server * server);
int getNumServers () const;
const Server * getServerByID (uint32_t server_id) const;
const Server * getServerBySort (int index) const;
void sort(bool sort_desc);
Server * getJoinedServer() const;
// Returns the best server to join
const Server * getQuickPlay() const;
const Server * getQuickPlay() const;
}; // class ServersManager
} // namespace Online

9
src/states_screens/server_selection.cpp
View File

@ -64,7 +64,7 @@ void ServerSelection::refresh()
m_server_list_widget->addItem("loading",
StringUtils::loadingDots(_("Fetching servers")));
m_reload_widget->setActive(false);
}
} // refresh
// ----------------------------------------------------------------------------
@ -88,7 +88,8 @@ void ServerSelection::beforeAddingWidget()
m_server_list_widget->clearColumns();
m_server_list_widget->addColumn( _("Name"), 3 );
m_server_list_widget->addColumn( _("Players"), 1);
}
} // beforeAddingWidget
// ----------------------------------------------------------------------------
void ServerSelection::init()
@ -110,11 +111,11 @@ void ServerSelection::init()
void ServerSelection::loadList()
{
m_server_list_widget->clear();
ServersManager * manager = ServersManager::get();
ServersManager *manager = ServersManager::get();
manager->sort(m_sort_desc);
for(int i=0; i < manager->getNumServers(); i++)
{
const Server * server = manager->getServerBySort(i);
const Server *server = manager->getServerBySort(i);
core::stringw num_players;
num_players.append(StringUtils::toWString(server->getCurrentPlayers()));
num_players.append("/");