projects/lib/src/engineconfiguration.cpp

   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 #include "engineconfiguration.h"
  19
  20 #include "engineoption.h"
  21 #include "engineoptionfactory.h"
  22
  23 EngineConfiguration::EngineConfiguration()
  24         : m_variants(QStringList() << "standard"),
  25           m_whiteEvalPov(false),
  26           m_restartMode(RestartAuto)
  27 {
  28 }
  29
  30 EngineConfiguration::EngineConfiguration(const QString& name,
  31                                          const QString& command,
  32                                          const QString& protocol)
  33         : m_name(name),
  34           m_command(command),
  35           m_protocol(protocol),
  36           m_variants(QStringList() << "standard"),
  37           m_whiteEvalPov(false),
  38           m_restartMode(RestartAuto)
  39 {
  40 }
  41
  42 EngineConfiguration::EngineConfiguration(const QVariant& variant)
  43         : m_variants(QStringList() << "standard"),
  44           m_whiteEvalPov(false),
  45           m_restartMode(RestartAuto)
  46 {
  47         const QVariantMap map = variant.toMap();
  48
  49         setName(map["name"].toString());
  50         setCommand(map["command"].toString());
  51         setWorkingDirectory(map["workingDirectory"].toString());
  52         setProtocol(map["protocol"].toString());
  53
  54         if (map.contains("initStrings"))
  55                 setInitStrings(map["initStrings"].toStringList());
  56         if (map.contains("whitepov"))
  57                 setWhiteEvalPov(map["whitepov"].toBool());
  58
  59         if (map.contains("restart"))
  60         {
  61                 const QString val(map["restart"].toString());
  62                 if (val == "auto")
  63                         setRestartMode(RestartAuto);
  64                 else if (val == "on")
  65                         setRestartMode(RestartOn);
  66                 else if (val == "off")
  67                         setRestartMode(RestartOff);
  68         }
  69
  70         if (map.contains("variants"))
  71                 setSupportedVariants(map["variants"].toStringList());
  72
  73         if (map.contains("options"))
  74         {
  75                 const QVariantList optionsList = map["options"].toList();
  76                 EngineOption* option = 0;
  77
  78                 foreach (const QVariant& optionVariant, optionsList)
  79                 {
  80                         if ((option = EngineOptionFactory::create(optionVariant.toMap())) != 0)
  81                                 addOption(option);
  82                 }
  83         }
  84 }
  85
  86 EngineConfiguration::EngineConfiguration(const EngineConfiguration& other)
  87         : m_name(other.m_name),
  88           m_command(other.m_command),
  89           m_workingDirectory(other.m_workingDirectory),
  90           m_protocol(other.m_protocol),
  91           m_arguments(other.m_arguments),
  92           m_initStrings(other.m_initStrings),
  93           m_variants(other.m_variants),
  94           m_whiteEvalPov(other.m_whiteEvalPov),
  95           m_restartMode(other.m_restartMode)
  96 {
  97         foreach (const EngineOption* option, other.options())
  98                 addOption(option->copy());
  99 }
 100
 101 EngineConfiguration::~EngineConfiguration()
 102 {
 103         qDeleteAll(m_options);
 104 }
 105
 106 QVariant EngineConfiguration::toVariant() const
 107 {
 108         QVariantMap map;
 109
 110         map.insert("name", m_name);
 111         map.insert("command", m_command);
 112         map.insert("workingDirectory", m_workingDirectory);
 113         map.insert("protocol", m_protocol);
 114
 115         if (!m_initStrings.isEmpty())
 116                 map.insert("initStrings", m_initStrings);
 117         if (m_whiteEvalPov)
 118                 map.insert("whitepov", true);
 119
 120         if (m_restartMode == RestartOn)
 121                 map.insert("restart", "on");
 122         else if (m_restartMode == RestartOff)
 123                 map.insert("restart", "off");
 124
 125         if (m_variants.count("standard") != m_variants.count())
 126                 map.insert("variants", m_variants);
 127
 128         if (!m_options.isEmpty())
 129         {
 130                 QVariantList optionsList;
 131                 foreach (const EngineOption* option, m_options)
 132                         optionsList.append(option->toVariant());
 133
 134                 map.insert("options", optionsList);
 135         }
 136
 137         return map;
 138 }
 139
 140 void EngineConfiguration::setName(const QString& name)
 141 {
 142         m_name = name;
 143 }
 144
 145 void EngineConfiguration::setCommand(const QString& command)
 146 {
 147         m_command = command;
 148 }
 149
 150 void EngineConfiguration::setProtocol(const QString& protocol)
 151 {
 152         m_protocol = protocol;
 153 }
 154
 155 void EngineConfiguration::setWorkingDirectory(const QString& workingDir)
 156 {
 157         m_workingDirectory = workingDir;
 158 }
 159
 160 QString EngineConfiguration::name() const
 161 {
 162         return m_name;
 163 }
 164
 165 QString EngineConfiguration::command() const
 166 {
 167         return m_command;
 168 }
 169
 170 QString EngineConfiguration::workingDirectory() const
 171 {
 172         return m_workingDirectory;
 173 }
 174
 175 QString EngineConfiguration::protocol() const
 176 {
 177         return m_protocol;
 178 }
 179
 180 QStringList EngineConfiguration::arguments() const
 181 {
 182         return m_arguments;
 183 }
 184
 185 void EngineConfiguration::setArguments(const QStringList& arguments)
 186 {
 187         m_arguments = arguments;
 188 }
 189
 190 void EngineConfiguration::addArgument(const QString& argument)
 191 {
 192         m_arguments << argument;
 193 }
 194
 195 QStringList EngineConfiguration::initStrings() const
 196 {
 197         return m_initStrings;
 198 }
 199
 200 void EngineConfiguration::setInitStrings(const QStringList& initStrings)
 201 {
 202         m_initStrings = initStrings;
 203 }
 204
 205 void EngineConfiguration::addInitString(const QString& initString)
 206 {
 207         m_initStrings << initString.split('\n');
 208 }
 209
 210 QStringList EngineConfiguration::supportedVariants() const
 211 {
 212         return m_variants;
 213 }
 214
 215 void EngineConfiguration::setSupportedVariants(const QStringList& variants)
 216 {
 217         m_variants = variants;
 218 }
 219
 220 QList<EngineOption*> EngineConfiguration::options() const
 221 {
 222         return m_options;
 223 }
 224
 225 void EngineConfiguration::setOptions(const QList<EngineOption*>& options)
 226 {
 227         qDeleteAll(m_options);
 228         m_options = options;
 229 }
 230
 231 void EngineConfiguration::addOption(EngineOption* option)
 232 {
 233         Q_ASSERT(option != 0);
 234
 235         m_options << option;
 236 }
 237
 238 bool EngineConfiguration::whiteEvalPov() const
 239 {
 240         return m_whiteEvalPov;
 241 }
 242
 243 void EngineConfiguration::setWhiteEvalPov(bool whiteEvalPov)
 244 {
 245         m_whiteEvalPov = whiteEvalPov;
 246 }
 247
 248 EngineConfiguration::RestartMode EngineConfiguration::restartMode() const
 249 {
 250         return m_restartMode;
 251 }
 252
 253 void EngineConfiguration::setRestartMode(RestartMode mode)
 254 {
 255         m_restartMode = mode;
 256 }
 257
 258 EngineConfiguration& EngineConfiguration::operator=(const EngineConfiguration& other)
 259 {
 260         if (this != &other)
 261         {
 262                 setName(other.name());
 263                 setCommand(other.command());
 264                 setProtocol(other.protocol());
 265                 setWorkingDirectory(other.workingDirectory());
 266                 setArguments(other.arguments());
 267                 setInitStrings(other.initStrings());
 268                 setSupportedVariants(other.supportedVariants());
 269                 setWhiteEvalPov(other.whiteEvalPov());
 270                 setRestartMode(other.restartMode());
 271
 272                 qDeleteAll(m_options);
 273                 m_options.clear();
 274
 275                 foreach (const EngineOption* option, other.options())
 276                         addOption(option->copy());
 277         }
 278         return *this;
 279 }