request.hpp

//  SuperTuxKart - a fun racing game with go-kart
//  Copyright (C) 2011-2015 Joerg Henrichs
//                2013 Glenn De Jonghe
//
//  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_ONLINE_REQUEST_HPP
#define HEADER_ONLINE_REQUEST_HPP
 
#include "utils/cpp2011.hpp"
#include "utils/no_copy.hpp"
#include "utils/synchronised.hpp"
 
#include <assert.h>
#include <memory>
#include <string>
 
namespace Online
{
    class Request : public std::enable_shared_from_this<Request>,
                    public NoCopy
    {
    private:
        const int m_type;
 
        const int m_priority;
 
        enum State
        {
            S_PREPARING,
            S_BUSY,
            S_EXECUTED,
            S_DONE
        };
 
    protected:
 
        Synchronised<bool>              m_cancel;
 
        Synchronised<bool>              m_is_abortable;
 
        Synchronised<State>             m_state;
 
        // --------------------------------------------------------------------
        virtual void operation() {}
 
        // --------------------------------------------------------------------
        virtual void prepareOperation() {}
 
        // --------------------------------------------------------------------
        virtual void afterOperation()   {}
 
    public:
        enum RequestType
        {
            RT_QUIT = 1
        };
 
        Request(int priority, int type);
        virtual ~Request() {}
        void     execute();
        void     executeNow();
        void     queue();
 
        // --------------------------------------------------------------------
        virtual void callback() {}
 
        // --------------------------------------------------------------------
        int getType() const  { return m_type; }
 
        // --------------------------------------------------------------------
        int getPriority() const   { return m_priority; }
 
        // --------------------------------------------------------------------
        void cancel() { m_cancel.setAtomic(true); }
 
        // --------------------------------------------------------------------
        bool isCancelled() const   { return m_cancel.getAtomic(); }
 
        // --------------------------------------------------------------------
        bool isAbortable() const { return m_is_abortable.getAtomic(); }
 
        // --------------------------------------------------------------------
        void setAbortable(bool b) { m_is_abortable.setAtomic(b); }
 
        // --------------------------------------------------------------------
        void setBusy()
        {
            assert(m_state.getAtomic() == S_PREPARING);
            m_state.setAtomic(S_BUSY);
        }   // setBusy
 
        // --------------------------------------------------------------------
        void setExecuted()
        {
            assert(m_state.getAtomic() == S_BUSY);
            m_state.setAtomic(S_EXECUTED);
        }   // setExecuted
 
        // --------------------------------------------------------------------
        void setDone()
        {
            assert(m_state.getAtomic() == S_EXECUTED);
            m_state.setAtomic(S_DONE);
        }   // setDone
 
        // --------------------------------------------------------------------
        bool isDone() const { return m_state.getAtomic() == S_DONE; }
 
        // --------------------------------------------------------------------
        bool isPreparing() const { return m_state.getAtomic() == S_PREPARING; }
 
        // --------------------------------------------------------------------
        bool isBusy() const   { return m_state.getAtomic() == S_BUSY; }
 
        // --------------------------------------------------------------------
        bool hasBeenExecuted() const
        {
            State s = m_state.getAtomic();
            return s == S_EXECUTED || s == S_DONE;
        }   // hasBeenExecuted
 
        // --------------------------------------------------------------------
        virtual bool isAllowedToAdd()   const   { return isPreparing(); }
 
        // ====================================================================
        class Compare
        {
        public:
            bool operator() (const std::shared_ptr<Request>& a,
                             const std::shared_ptr<Request>& b) const
            {
                return a->getPriority() < b->getPriority();
            }
        };   // class Compare
    };   // class Request
} //namespace Online
#endif // HEADER_ONLINE_REQUEST_HPP