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

acquire/release approach removed for ServersManager. Added MutexLocker to synchronised.hpp. CurrentUser will folow after sleepy times.

Browse Source 
git-svn-id: svn+ssh://svn.code.sf.net/p/supertuxkart/code/main/branches/uni@13346 178a84e3-b1eb-0310-8ba1-8eac791a3b58
This commit is contained in:
unitraxx
2013-07-25 02:22:53 +00:00
parent aba6b9f0e6
commit 261957bf72
9 changed files with 123 additions and 91 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
src/online/current_user.cpp
View File

@@ -168,8 +168,7 @@ namespace Online{
if(isSuccess())
{
Server * server = new Server(*getResult()->getNode("server"));
ServersManager::acquire()->addServer(server);
ServersManager::release();
ServersManager::get()->addServer(server);
m_created_server_id.setAtomic(server->getServerId());
}
}
@@ -228,8 +227,7 @@ namespace Online{
{
uint32_t server_id;
getResult()->get("serverid", &server_id);
ServersManager::acquire()->setJoinedServer(server_id);
ServersManager::release();
ServersManager::get()->setJoinedServer(server_id);
}
//FIXME needs changes for actual valid joining
}

2
src/online/request.hpp
View File

@@ -193,7 +193,7 @@ namespace Online{
virtual ~XMLRequest();
virtual XMLNode * getResult() const { return m_result; }
const irr::core::stringw getInfo() {
const irr::core::stringw getInfo() const {
m_info.lock();
const irr::core::stringw info = m_info.getData();
m_info.unlock();

113
src/online/servers_manager.cpp
View File

@@ -30,60 +30,51 @@
namespace Online{
static Synchronised<ServersManager*> manager_singleton(NULL);
static ServersManager* manager_singleton(NULL);
ServersManager* ServersManager::acquire()
ServersManager* ServersManager::get()
{
manager_singleton.lock();
ServersManager * manager = manager_singleton.getData();
if (manager == NULL)
{
manager_singleton.unlock();
manager = new ServersManager();
manager_singleton.setAtomic(manager);
manager_singleton.lock();
}
return manager;
}
void ServersManager::release()
{
manager_singleton.unlock();
if (manager_singleton == NULL)
manager_singleton = new ServersManager();
return manager_singleton;
}
void ServersManager::deallocate()
{
manager_singleton.lock();
ServersManager* manager = manager_singleton.getData();
delete manager;
manager = NULL;
manager_singleton.unlock();
delete manager_singleton;
manager_singleton = NULL;
} // deallocate
// ============================================================================
ServersManager::ServersManager(){
m_info_message = "";
m_last_load_time = 0.0f;
m_joined_server = NULL;
m_info_message.setAtomic("");
m_last_load_time.setAtomic(0.0f);
m_joined_server.setAtomic(NULL);
}
ServersManager::~ServersManager(){
cleanUpServers();
delete m_joined_server;
m_joined_server.lock();
delete m_joined_server.getData();
m_joined_server.unlock();
}
// ============================================================================
void ServersManager::cleanUpServers()
{
m_sorted_servers.clearAndDeleteAll();
m_mapped_servers.clear();
m_sorted_servers.lock();
m_sorted_servers.getData().clearAndDeleteAll();
m_sorted_servers.unlock();
m_mapped_servers.lock();
m_mapped_servers.getData().clear();
m_mapped_servers.unlock();
}
// ============================================================================
ServersManager::RefreshRequest * ServersManager::refreshRequest()
const ServersManager::RefreshRequest * ServersManager::refreshRequest() const
{
RefreshRequest * request = NULL;
if(Time::getRealTime() - m_last_load_time > SERVER_REFRESH_INTERVAL)
if(Time::getRealTime() - m_last_load_time.getAtomic() > SERVER_REFRESH_INTERVAL)
{
request = new RefreshRequest();
request->setURL((std::string)UserConfigParams::m_server_multiplayer + "client-user.php");
@@ -103,63 +94,87 @@ namespace Online{
{
addServer(new Server(*servers_xml->getNode(i)));
}
m_last_load_time = Time::getRealTime();
m_last_load_time.setAtomic(Time::getRealTime());
}
m_info_message = input->getInfo();
m_info_message.setAtomic(input->getInfo());
//FIXME error message
}
void ServersManager::RefreshRequest::callback()
{
ServersManager::acquire()->refresh(this);
ServersManager::release();
ServersManager::get()->refresh(this);
}
// ============================================================================
Server * ServersManager::getQuickPlay()
const Server * ServersManager::getQuickPlay() const
{
if(m_sorted_servers.size() > 0)
/*if(m_sorted_servers.size() > 0)
return getServerBySort(0);
return NULL;
return NULL;*/
}
// ============================================================================
void ServersManager::setJoinedServer(uint32_t id)
{
delete m_joined_server;
m_joined_server.lock();
delete m_joined_server.getData();
//It's a copy!
m_joined_server = new Server(*getServerByID(id));
m_joined_server.getData() = new Server(*getServerByID(id));
m_joined_server.unlock();
}
// ============================================================================
void ServersManager::unsetJoinedServer()
{
delete m_joined_server;
m_joined_server = NULL;
m_joined_server.lock();
delete m_joined_server.getData();
m_joined_server.getData() = NULL;
m_joined_server.unlock();
}
// ============================================================================
void ServersManager::addServer(Server * server)
{
m_sorted_servers.push_back(server);
m_mapped_servers[server->getServerId()] = server;
m_sorted_servers.lock();
m_sorted_servers.getData().push_back(server);
m_sorted_servers.unlock();
m_mapped_servers.lock();
m_mapped_servers.getData()[server->getServerId()] = server;
m_mapped_servers.unlock();
}
// ============================================================================
int ServersManager::getNumServers ()
int ServersManager::getNumServers () const
{
return m_sorted_servers.size();
MutexLocker locker(m_sorted_servers);
return m_sorted_servers.getData().size();
}
// ============================================================================
Server * ServersManager::getServerBySort (int index)
const Server * ServersManager::getServerBySort (int index) const
{
return m_sorted_servers.get(index);
MutexLocker locker(m_sorted_servers);
return m_sorted_servers.getData().get(index);
}
// ============================================================================
Server * ServersManager::getServerByID (uint32_t id)
const Server * ServersManager::getServerByID (uint32_t id) const
{
return m_mapped_servers[id];
MutexLocker locker(m_mapped_servers);
return m_mapped_servers.getData().at(id);
}
// ============================================================================
Server * ServersManager::getJoinedServer() const
{
return m_joined_server.getAtomic();
}
// ============================================================================
void ServersManager::sort(bool sort_desc){
m_sorted_servers.lock();
m_sorted_servers.getData().insertionSort(0, sort_desc);
m_sorted_servers.unlock();
}
} // namespace Online

42
src/online/servers_manager.hpp
View File

@@ -23,6 +23,8 @@
#include "utils/types.hpp"
#include "online/server.hpp"
#include "http_manager.hpp"
#include "utils/synchronised.hpp"
@@ -51,35 +53,33 @@ namespace Online {
ServersManager();
~ServersManager();
/** Sorted vector of servers */
PtrVector<Server> m_sorted_servers;
Synchronised<PtrVector<Server> > m_sorted_servers;
/** Maps server id's to the same servers*/
std::map<uint32_t, Server*> m_mapped_servers;
Synchronised<std::map<uint32_t, Server*> > m_mapped_servers;
/** This is a pointer to a copy of the server, the moment it got joined */
Server * m_joined_server;
Synchronised<Server *> m_joined_server;
bool m_not_fetched;
irr::core::stringw m_info_message;
float m_last_load_time;
void refresh(RefreshRequest * input);
void cleanUpServers();
Synchronised<irr::core::stringw> m_info_message;
Synchronised<float> m_last_load_time;
void refresh(RefreshRequest * input);
void cleanUpServers();
public:
// Singleton
static ServersManager* acquire();
static void release();
static void deallocate();
static ServersManager* get();
static void deallocate();
RefreshRequest * refreshRequest();
void setJoinedServer(uint32_t server_id);
void unsetJoinedServer();
void addServer(Server * server);
int getNumServers ();
Server * getServerByID (uint32_t server_id);
Server * getServerBySort (int index);
void sort(bool sort_desc) { m_sorted_servers.insertionSort(0, sort_desc); }
Server * getJoinedServer() { return m_joined_server; }
const RefreshRequest * refreshRequest() 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
Server * getQuickPlay();
const Server * getQuickPlay() const;
}; // class ServersManager

3
src/states_screens/dialogs/server_info_dialog.cpp
View File

@@ -53,9 +53,8 @@ ServerInfoDialog::ServerInfoDialog(uint32_t server_id, bool from_server_creation
m_name_widget = getWidget<LabelWidget>("name");
assert(m_name_widget != NULL);
Server * server = ServersManager::acquire()->getServerByID(m_server_id);
const Server * server = ServersManager::get()->getServerByID(m_server_id);
m_name_widget->setText(server->getName(),false);
ServersManager::release();
m_info_widget = getWidget<LabelWidget>("info");
assert(m_info_widget != NULL);
if (m_from_server_creation)

3
src/states_screens/networking_lobby.cpp
View File

@@ -84,8 +84,7 @@ void NetworkingLobby::init()
Screen::init();
setInitialFocus();
DemoWorld::resetIdleTime(); //FIXME : what's this?
m_server = ServersManager::acquire()->getJoinedServer();
ServersManager::release();
m_server = ServersManager::get()->getJoinedServer();
m_server_name_widget->setText(m_server->getName(),false);
} // init

11
src/states_screens/server_selection.cpp
View File

@@ -60,8 +60,7 @@ void ServerSelection::tearDown()
void ServerSelection::refresh()
{
m_refresh_request = ServersManager::acquire()->refreshRequest();
ServersManager::release();
m_refresh_request = ServersManager::get()->refreshRequest();
m_fake_refresh = (m_refresh_request == NULL ? true : false);
m_server_list_widget->clear();
m_server_list_widget->addItem("spacer", L"");
@@ -113,11 +112,11 @@ void ServerSelection::init()
void ServerSelection::loadList()
{
m_server_list_widget->clear();
ServersManager * manager = ServersManager::acquire();
ServersManager * manager = ServersManager::get();
manager->sort(m_sort_desc);
for(int i=0; i < manager->getNumServers(); i++)
{
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("/");
@@ -127,7 +126,6 @@ void ServerSelection::loadList()
row->push_back(new GUIEngine::ListWidget::ListCell(num_players,-1,1,true));
m_server_list_widget->addItem("server", row);
}
ServersManager::release();
} // loadList
// ----------------------------------------------------------------------------
@@ -162,8 +160,7 @@ void ServerSelection::eventCallback( GUIEngine::Widget* widget,
else if (name == m_server_list_widget->m_properties[GUIEngine::PROP_ID])
{
m_selected_index = m_server_list_widget->getSelectionID();
uint32_t server_id = ServersManager::acquire()->getServerBySort(m_selected_index)->getServerId();
ServersManager::release();
uint32_t server_id = ServersManager::get()->getServerBySort(m_selected_index)->getServerId();
new ServerInfoDialog(server_id);
}

2
src/states_screens/server_selection.hpp
View File

@@ -53,7 +53,7 @@ private:
/** \brief To check (and set) if sort order is descending **/
bool m_sort_desc;
Online::ServersManager::RefreshRequest * m_refresh_request;
const Online::ServersManager::RefreshRequest * m_refresh_request;
bool m_fake_refresh;
void refresh();

32
src/utils/synchronised.hpp
View File

@@ -21,11 +21,20 @@
#include <pthread.h>
template<typename TYPE>
class ISynchronised
{
public :
virtual ~ISynchronised() {}
virtual void lock() const = 0 ;
virtual void unlock() const = 0;
};
/** A variable that is automatically synchronised using pthreads mutex.
*/
class Synchronised
template<typename TYPE>
class Synchronised : public ISynchronised
{
private:
/** The mutex to protect this variable with. */
@@ -97,11 +106,11 @@ public:
/** Locks the mutex. Note that calls to get() or set() will fail, since
* they will try to lock the mutex as well!
*/
void lock() { pthread_mutex_lock(&m_mutex); }
void lock() const { pthread_mutex_lock(&m_mutex); }
// ------------------------------------------------------------------------
/** Unlocks the mutex.
*/
void unlock() {pthread_mutex_unlock(&m_mutex); }
void unlock() const {pthread_mutex_unlock(&m_mutex); }
// ------------------------------------------------------------------------
/** Gives access to the mutex, which can then be used in other pthread
* calls (e.g. pthread_cond_wait).
@@ -114,4 +123,19 @@ private:
};
class MutexLocker
{
const ISynchronised * m_synchronised;
public:
MutexLocker(const ISynchronised & synchronised){
m_synchronised = &synchronised;
m_synchronised->lock();
}
~MutexLocker(){
m_synchronised->unlock();
}
};
#endif