• Doomseeker
• Wadseeker
• Download
• Tracker
• Mercurial
• Docs

src/core/masterserver/mastermanager.h

//------------------------------------------------------------------------------
// mastermanager.h
//------------------------------------------------------------------------------
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
// 02110-1301, USA.
//
//------------------------------------------------------------------------------
// Copyright (C) 2009 "Blzut3" <admin@maniacsvault.net>
//------------------------------------------------------------------------------
#ifndef __MASTERMANAGER_H__
#define __MASTERMANAGER_H__

#include "masterserver/masterclient.h"
#include "serverapi/message.h"

class CustomServers;
class MasterClientSignalProxy;

class MasterManager : public MasterClient
{
        Q_OBJECT

        public:
                MasterManager();
                ~MasterManager();

                void                                                            addMaster(MasterClient *master);
                void                                                            clearServersList() { servers.clear(); }
                CustomServers*                                          customServs() { return customServers; }

                int                                                                     numMasters() const { return masters.size(); }

                const EnginePlugin*                                     plugin() const { return NULL; }

                MasterClient*                                           operator[](int index) { return masters[index]; }

                bool                                                            readMasterResponse(QByteArray &data) { return false; }

                bool                                                            readMasterResponse(QHostAddress& address, unsigned short port, QByteArray &data);


        public slots:
                void                                                            refresh();

        signals:
                void                                                            listUpdatedForMaster(MasterClient* pSender);
                void                                                            masterMessage(MasterClient* pSender, const QString& title, const QString& content, bool isError);
                void                                                            masterMessageImportant(MasterClient* pSender, const Message& objMessage);
                void                                                            newServerBatchReceivedFromMaster(MasterClient* pSender, const QList<Server* >& servers);

        protected:
                CustomServers*                                          customServers;
                QList<MasterClient *>                           masters;
                QSet<MasterClient *>                            mastersBeingRefreshed;
                QList<MasterClientSignalProxy*>         mastersReceivers;

                bool                                                            getServerListRequest(QByteArray &data) { return false; }
                void                                                            timeoutRefreshEx();

        protected slots:
                void                                                            masterListUpdated(MasterClient* pSender);

                void                                                            readMasterMessage(MasterClient* pSender, const QString& title, const QString& content, bool isError)
                {
                        emit masterMessage(pSender, title, content, isError);
                }

                void                                                            newServerBatchReceivedSlot(MasterClient* pSender, const QList<Server* >& servers)
                {
                        emit newServerBatchReceivedFromMaster(pSender, servers);
                }
};

#endif

   

Doomseeker © 2009-2018 The Doomseeker Team