projects/lib/src/pgngamefilter.h

   1 /*
   2     This file is part of Cute Chess.
   3
   4     Cute Chess is free software: you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation, either version 3 of the License, or
   7     (at your option) any later version.
   8
   9     Cute Chess is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with Cute Chess.  If not, see <http://www.gnu.org/licenses/>.
  16 */
  17
  18 #ifndef PGNGAMEFILTER_H
  19 #define PGNGAMEFILTER_H
  20
  21 #include <QByteArray>
  22 #include <QDate>
  23 #include <board/side.h>
  24 class QString;
  25 class PgnGameEntry;
  26
  27 /*!
  28  * \brief A filter for chess games in a PGN database.
  29  *
  30  * A PgnGameFilter object can be used to filter games in a PGN
  31  * database by matching the filtering terms to the games' PGN
  32  * tags.
  33  *
  34  * \sa PgnGameEntry
  35  */
  36 class LIB_EXPORT PgnGameFilter
  37 {
  38         public:
  39                 /*! The type of the filter. */
  40                 enum Type
  41                 {
  42                         /*! Filter all tags with a single fixed string. */
  43                         FixedString,
  44                         /*! Use invididual filtering terms for each tag. */
  45                         Advanced
  46                 };
  47
  48                 /*! The result of the game. */
  49                 enum Result
  50                 {
  51                         AnyResult,              //!< Any result (no filtering)
  52                         EitherPlayerWins,       //!< Either player wins
  53                         WhiteWins,              //!< The white player wins
  54                         BlackWins,              //!< The black player wins
  55                         FirstPlayerWins,        //!< The first player wins
  56                         FirstPlayerLoses,       //!< The first player loses
  57                         Draw,                   //!< The game is a draw
  58                         Unfinished              //!< The game wasn't completed
  59                 };
  60
  61                 /*!
  62                  * Creates a new empty filter.
  63                  *
  64                  * An empty filter will not filter out any games.
  65                  * The filter's type is \a Advanced.
  66                  */
  67                 PgnGameFilter();
  68                 /*!
  69                  * Creates a new filter based on a fixed string.
  70                  *
  71                  * Games that have tags matching \a pattern will be filtered in.
  72                  * The filter's type is \a FixedString.
  73                  */
  74                 PgnGameFilter(const QString& pattern);
  75
  76                 /*! Returns the type of the filter. */
  77                 Type type() const;
  78
  79                 /*! Returns the pattern for \a FixedString mode. */
  80                 const char* pattern() const;
  81
  82                 /*! Returns the filter for the \a Event tag. */
  83                 const char* event() const;
  84                 /*! Returns the filter for the \a Site tag. */
  85                 const char* site() const;
  86                 /*!
  87                  * Returns the filter for the first player.
  88                  *
  89                  * The first player's side/color is determined by the
  90                  * playerSide() member function.
  91                  */
  92                 const char* player() const;
  93                 /*! Returns the filter for the opponent of the first player. */
  94                 const char* opponent() const;
  95                 /*! Returns the filter for the side/color of the first player. */
  96                 Chess::Side playerSide() const;
  97                 /*!
  98                  * Returns the filter for the game's minimum starting date.
  99                  *
 100                  * \note A null QDate won't filter out any games.
 101                  */
 102                 const QDate& minDate() const;
 103                 /*!
 104                  * Returns the filter for the game's maximum starting date.
 105                  *
 106                  * \note A null QDate won't filter out any games.
 107                  */
 108                 const QDate& maxDate() const;
 109                 /*! Returns the filter for the minimum round ordinal. */
 110                 int minRound() const;
 111                 /*! Returns the filter for the maximum round ordinal. */
 112                 int maxRound() const;
 113                 /*! Returns the filter for the \a Result tag. */
 114                 Result result() const;
 115                 /*!
 116                  * Returns true if the filter is looking for the inverse
 117                  * of \a result(); otherwise returns false.
 118                  */
 119                 bool isResultInverted() const;
 120
 121                 /*!
 122                  * Sets the \a FixedString pattern to \a pattern.
 123                  *
 124                  * This function will change the filter type to \a FixedString.
 125                  */
 126                 void setPattern(const QString& pattern);
 127
 128                 /*! Sets the \a Event tag filter to \a event. */
 129                 void setEvent(const QString& event);
 130                 /*! Sets the \a Site tag filter to \a site. */
 131                 void setSite(const QString& site);
 132                 /*! Sets the minimum starting date filter to \a date. */
 133                 void setMinDate(const QDate& date);
 134                 /*! Sets the maximum starting date filter to \a date. */
 135                 void setMaxDate(const QDate& date);
 136                 /*! Sets the minimum round ordinal filter to \a round. */
 137                 void setMinRound(int round);
 138                 /*! Sets the maximum round ordinal filter to \a round. */
 139                 void setMaxRound(int round);
 140                 /*! Sets the \a side player's filter to \a name. */
 141                 void setPlayer(const QString& name, Chess::Side side);
 142                 /*! Sets the first player's opponent filter to \a name. */
 143                 void setOpponent(const QString& name);
 144                 /*! Sets the \a Result tag filter to \a result. */
 145                 void setResult(Result result);
 146                 /*! Sets the \a resultInverted value to \a invert. */
 147                 void setResultInverted(bool invert);
 148
 149         private:
 150                 Type m_type;
 151                 QByteArray m_pattern;
 152                 QByteArray m_event;
 153                 QByteArray m_site;
 154                 QByteArray m_player;
 155                 QByteArray m_opponent;
 156                 Chess::Side m_playerSide;
 157                 QDate m_minDate;
 158                 QDate m_maxDate;
 159                 int m_minRound;
 160                 int m_maxRound;
 161                 Result m_result;
 162                 bool m_resultInverted;
 163 };
 164
 165 inline PgnGameFilter::Type PgnGameFilter::type() const
 166 {
 167         return m_type;
 168 }
 169
 170 inline const char* PgnGameFilter::pattern() const
 171 {
 172         return m_pattern.constData();
 173 }
 174
 175 inline const char* PgnGameFilter::event() const
 176 {
 177         return m_event.constData();
 178 }
 179
 180 inline const char* PgnGameFilter::site() const
 181 {
 182         return m_site.constData();
 183 }
 184
 185 inline const QDate& PgnGameFilter::minDate() const
 186 {
 187         return m_minDate;
 188 }
 189
 190 inline const QDate& PgnGameFilter::maxDate() const
 191 {
 192         return m_maxDate;
 193 }
 194
 195 inline int PgnGameFilter::minRound() const
 196 {
 197         return m_minRound;
 198 }
 199
 200 inline int PgnGameFilter::maxRound() const
 201 {
 202         return m_maxRound;
 203 }
 204
 205 inline PgnGameFilter::Result PgnGameFilter::result() const
 206 {
 207         return m_result;
 208 }
 209
 210 inline bool PgnGameFilter::isResultInverted() const
 211 {
 212         return m_resultInverted;
 213 }
 214
 215 inline const char* PgnGameFilter::player() const
 216 {
 217         return m_player.constData();
 218 }
 219
 220 inline const char* PgnGameFilter::opponent() const
 221 {
 222         return m_opponent.constData();
 223 }
 224
 225 inline Chess::Side PgnGameFilter::playerSide() const
 226 {
 227         return m_playerSide;
 228 }
 229
 230 #endif // PGNGAMEFILTER_H