chessengine.h

/*
    This file is part of Cute Chess.
    Copyright (C) 2008-2018 Cute Chess authors
 
    Cute Chess 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.
 
    Cute Chess 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 Cute Chess.  If not, see <http://www.gnu.org/licenses/>.
*/
 
#ifndef CHESSENGINE_H
#define CHESSENGINE_H
 
#include "chessplayer.h"
#include <QVariant>
#include <QStringList>
#include "engineconfiguration.h"
 
class QIODevice;
class EngineOption;
 

class LIB_EXPORT ChessEngine : public ChessPlayer
{
    Q_OBJECT
 
    public:
        enum WriteMode
        {
            Buffered,   
            Unbuffered  
        };

        ChessEngine(QObject* parent = nullptr);
        virtual ~ChessEngine();

        QIODevice* device() const;
        void setDevice(QIODevice* device);
 
        // Inherited from ChessPlayer
        virtual void endGame(const Chess::Result& result);
        virtual bool isHuman() const;
        virtual bool isReady() const;
        virtual bool supportsVariant(const QString& variant) const;

        void start();

        void applyConfiguration(const EngineConfiguration& configuration);

        void ping(bool sendCommand = true);
        
        virtual QString protocol() const = 0;

        void write(const QString& data, WriteMode mode = Buffered);

        void setOption(const QString& name, const QVariant& value);

        QList<EngineOption*> options() const;

        QStringList variants() const;
 
    public slots:
        // Inherited from ChessPlayer
        virtual void go();
        virtual void quit();
        virtual void kill();
        
    protected:
        static QStringRef firstToken(const QString& str,
                         bool readToEnd = false);
        static QStringRef nextToken(const QStringRef& previous,
                        bool readToEnd = false);
 
        // Inherited from ChessPlayer
        virtual void startGame() = 0;

        virtual void startProtocol() = 0;

        virtual void parseLine(const QString& line) = 0;

        virtual bool sendPing() = 0;

        virtual void sendStop() = 0;

        virtual void sendQuit() = 0;

        bool stopThinking();

        void addOption(EngineOption* option);
        EngineOption* getOption(const QString& name) const;
        virtual void sendOption(const QString& name, const QVariant& value) = 0;

        void addVariant(const QString& variant);
        void clearVariants();

        EngineConfiguration::RestartMode restartMode() const;
        virtual bool restartsBetweenGames() const;
        virtual bool isPondering() const;

        bool whiteEvalPov() const;
        bool pondering() const;
        int id() const;
 
    protected slots:
        // Inherited from ChessPlayer
        virtual void onTimeout();

        void onReadyRead();

        void onPingTimeout();

        void onIdleTimeout();

        void pong(bool emitReady = true);

        void onProtocolStart();

        void flushWriteBuffer();

        void clearWriteBuffer();
 
    private slots:
        void onQuitTimeout();
        void onProtocolStartTimeout();
 
    private:
        static int s_count;
 
        int m_id;
        State m_pingState;
        bool m_pinging;
        bool m_whiteEvalPov;
        bool m_pondering;
        QTimer* m_pingTimer;
        QTimer* m_quitTimer;
        QTimer* m_idleTimer;
        QTimer* m_protocolStartTimer;
        QIODevice *m_ioDevice;
        QStringList m_writeBuffer;
        QStringList m_variants;
        QList<EngineOption*> m_options;
        QMap<QString, QVariant> m_optionBuffer;
        EngineConfiguration::RestartMode m_restartMode;
};
 
#endif // CHESSENGINE_H