pgngamefilter.h

/*
    This file is part of Cute Chess.

    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 PGNGAMEFILTER_H
#define PGNGAMEFILTER_H

#include <QByteArray>
#include <QDate>
#include "board/side.h"
class QString;
class PgnGameEntry;

class LIB_EXPORT PgnGameFilter
{
    public:
        enum Type
        {
            FixedString,
            Advanced
        };

        enum Result
        {
            AnyResult,      
            EitherPlayerWins,   
            WhiteWins,      
            BlackWins,      
            FirstPlayerWins,    
            FirstPlayerLoses,   
            Draw,           
            Unfinished      
        };

        PgnGameFilter();
        PgnGameFilter(const QString& pattern);

        Type type() const;

        const char* pattern() const;

        const char* event() const;
        const char* site() const;
        const char* player() const;
        const char* opponent() const;
        Chess::Side playerSide() const;
        const QDate& minDate() const;
        const QDate& maxDate() const;
        int minRound() const;
        int maxRound() const;
        Result result() const;
        bool isResultInverted() const;

        void setPattern(const QString& pattern);

        void setEvent(const QString& event);
        void setSite(const QString& site);
        void setMinDate(const QDate& date);
        void setMaxDate(const QDate& date);
        void setMinRound(int round);
        void setMaxRound(int round);
        void setPlayer(const QString& name, Chess::Side side);
        void setOpponent(const QString& name);
        void setResult(Result result);
        void setResultInverted(bool invert);

    private:
        Type m_type;
        QByteArray m_pattern;
        QByteArray m_event;
        QByteArray m_site;
        QByteArray m_player;
        QByteArray m_opponent;
        Chess::Side m_playerSide;
        QDate m_minDate;
        QDate m_maxDate;
        int m_minRound;
        int m_maxRound;
        Result m_result;
        bool m_resultInverted;
};

inline PgnGameFilter::Type PgnGameFilter::type() const
{
    return m_type;
}

inline const char* PgnGameFilter::pattern() const
{
    return m_pattern.constData();
}

inline const char* PgnGameFilter::event() const
{
    return m_event.constData();
}

inline const char* PgnGameFilter::site() const
{
    return m_site.constData();
}

inline const QDate& PgnGameFilter::minDate() const
{
    return m_minDate;
}

inline const QDate& PgnGameFilter::maxDate() const
{
    return m_maxDate;
}

inline int PgnGameFilter::minRound() const
{
    return m_minRound;
}

inline int PgnGameFilter::maxRound() const
{
    return m_maxRound;
}

inline PgnGameFilter::Result PgnGameFilter::result() const
{
    return m_result;
}

inline bool PgnGameFilter::isResultInverted() const
{
    return m_resultInverted;
}

inline const char* PgnGameFilter::player() const
{
    return m_player.constData();
}

inline const char* PgnGameFilter::opponent() const
{
    return m_opponent.constData();
}

inline Chess::Side PgnGameFilter::playerSide() const
{
    return m_playerSide;
}

#endif // PGNGAMEFILTER_H