news_manager.hpp

//  SuperTuxKart - a fun racing game with go-kart
//  Copyright (C) 2011-2015 Joerg Henrichs
//
//  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 3
//  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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 
#ifndef HEADER_NEWS_MANAGER_HPP
#define HEADER_NEWS_MANAGER_HPP
 
#ifndef SERVER_ONLY
 
#include <string>
#include <thread>
#include <vector>
 
 
#include <irrString.h>
using namespace irr;
 
#include "utils/can_be_deleted.hpp"
#include "utils/synchronised.hpp"
 
class XMLNode;
 
class NewsManager : public CanBeDeleted
{
public:
    // Means the exact place the news being shown
    enum NewsType : uint8_t
    {
        NTYPE_MAINMENU,
        NTYPE_LIST,
        NTYPE_COUNT
    };
 
private:
    static NewsManager *m_news_manager;
 
    // A wrapper class to store news message together with
    // a message id and a display count.
    class NewsMessage
    {
        core::stringw m_news;
        std::string   m_date;
        std::string   m_link;
        int           m_message_id;
        int           m_display_count;
        bool          m_important;
 
    public:
        NewsMessage(const core::stringw &m, int id, const std::string &date="", 
                    const std::string &link="", bool important=false)
        {
            m_news          = m;
            m_date          = date;
            m_link          = link;
            m_message_id    = id;
            m_display_count = 0;
            m_important     = important;
        }   // NewsMessage
        const core::stringw& getNews() const { return m_news; }
        const std::string& getDate() const { return m_date; }
        const std::string& getLink() const { return m_link; }
        void increaseDisplayCount() { m_display_count++; }
        int  getMessageId() const { return m_message_id; }
        int getDisplayCount() const { return m_display_count; }
        void setDisplayCount(int n) { m_display_count = n; }
        bool isImportant() const { return m_important; }
        bool operator<(NewsMessage other) const
        {
            return m_important == other.m_important
                 ? m_message_id > other.m_message_id
                 : m_important;
        }
    };   // NewsMessage
 
    static std::string m_news_filename;
 
    mutable Synchronised< std::vector<NewsMessage> > m_news[NTYPE_COUNT];
 
    int             m_current_news_ptr[NTYPE_COUNT];
    int             m_news_prioritize_after_id[NTYPE_COUNT];
 
    std::vector<int> m_saved_display_count;
 
    Synchronised<core::stringw>    m_error_message;
 
    bool m_force_refresh;
 
    std::thread m_download_thread;
 
    void          checkRedirect(const XMLNode *xml);
    void          updateNews(const XMLNode *xml,
                             const std::string &filename);
    bool          conditionFulfilled(const std::string &cond);
    void          downloadNews();
    NewsManager();
    ~NewsManager();
 
public:
    static NewsManager* get()
    {
        if(!m_news_manager)
            m_news_manager = new NewsManager();
        return m_news_manager;
    }   // get
    // ------------------------------------------------------------------------
    static bool isRunning() { return m_news_manager != NULL; }
    // ------------------------------------------------------------------------
    static void deallocate()
    {
        if(m_news_manager)
        {
            delete m_news_manager;
            m_news_manager = NULL;
        }
    }   // deallocate
    // ------------------------------------------------------------------------
    const int     getNextNewsID(NewsType type);
    const core::stringw
                  getCurrentNewsMessage(NewsType type);
    const std::string
                  getCurrentNewsDate(NewsType type);
    const std::string
                  getCurrentNewsLink(NewsType type);
    const bool    isCurrentNewsImportant(NewsType type);
    const int     getNewsCount(NewsType type);
 
    void          prioritizeNewsAfterID(NewsType type, int id);
    
    void          init(bool force_refresh);
    void          addNewsMessage(NewsType type, const core::stringw &s);
 
    // ------------------------------------------------------------------------
    void          resetNewsPtr(NewsType type) { m_current_news_ptr[type] = -1; }
    bool          isNewsFetching(NewsType type) { return m_current_news_ptr[type] != -1; }
    // ------------------------------------------------------------------------
    void          setErrorMessage(const core::stringw &s)
    {
        m_error_message.setAtomic(s);
    }   // setErrorMessage
    // ------------------------------------------------------------------------
    void          clearErrorMessage() { m_error_message.setAtomic(""); }
    // ------------------------------------------------------------------------
    void          joinDownloadThreadIfExit()
    {
        if (CanBeDeleted::canBeDeletedNow() && m_download_thread.joinable())
            m_download_thread.join();
    }
};   // NewsManager
 
#endif
#endif