src/gromacs/options/basicoptions.cpp

   1 /*
   2  * This file is part of the GROMACS molecular simulation package.
   3  *
   4  * Copyright (c) 2010,2011,2012,2013, by the GROMACS development team, led by
   5  * David van der Spoel, Berk Hess, Erik Lindahl, and including many
   6  * others, as listed in the AUTHORS file in the top-level source
   7  * directory and at http://www.gromacs.org.
   8  *
   9  * GROMACS is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public License
  11  * as published by the Free Software Foundation; either version 2.1
  12  * of the License, or (at your option) any later version.
  13  *
  14  * GROMACS is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with GROMACS; if not, see
  21  * http://www.gnu.org/licenses, or write to the Free Software Foundation,
  22  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA.
  23  *
  24  * If you want to redistribute modifications to GROMACS, please
  25  * consider that scientific software is very special. Version
  26  * control is crucial - bugs must be traceable. We will be happy to
  27  * consider code for inclusion in the official distribution, but
  28  * derived work must not be called official GROMACS. Details are found
  29  * in the README & COPYING files - if they are missing, get the
  30  * official version at http://www.gromacs.org.
  31  *
  32  * To help us fund GROMACS development, we humbly ask that you cite
  33  * the research papers on the package. Check out http://www.gromacs.org.
  34  */
  35 /*! \internal \file
  36  * \brief
  37  * Implements classes in basicoptions.h and basicoptionstorage.h.
  38  *
  39  * \author Teemu Murtola <teemu.murtola@gmail.com>
  40  * \ingroup module_options
  41  */
  42 #include "basicoptions.h"
  43 #include "basicoptionstorage.h"
  44
  45 #include <cerrno>
  46 #include <cstdio>
  47 #include <cstdlib>
  48
  49 #include <limits>
  50 #include <string>
  51 #include <vector>
  52
  53 #include "gromacs/utility/exceptions.h"
  54 #include "gromacs/utility/stringutil.h"
  55
  56 namespace
  57 {
  58
  59 /*! \brief
  60  * Expands a single value to a vector by copying the value.
  61  *
  62  * \tparam        ValueType  Type of values to process.
  63  * \param[in]     length     Length of the resulting vector.
  64  * \param[in,out] values     Values to process.
  65  * \throws   std::bad_alloc    if out of memory.
  66  * \throws   InvalidInputError if \p values has an invalid number of values.
  67  *
  68  * \p values should have 0, 1, or \p length values.
  69  * If \p values has 1 value, it is expanded such that it has \p length
  70  * identical values.  In other valid cases, nothing is done.
  71  */
  72 template <typename ValueType>
  73 void expandVector(size_t length, std::vector<ValueType> *values)
  74 {
  75     if (length > 0 && values->size() > 0 && values->size() != length)
  76     {
  77         if (values->size() != 1)
  78         {
  79             GMX_THROW(gmx::InvalidInputError(gmx::formatString(
  80                                                      "Expected 1 or %d values, got %d", length, values->size())));
  81         }
  82         const ValueType &value = (*values)[0];
  83         values->resize(length, value);
  84     }
  85 }
  86
  87 } // namespace
  88
  89 namespace gmx
  90 {
  91
  92 /********************************************************************
  93  * BooleanOptionStorage
  94  */
  95
  96 std::string BooleanOptionStorage::formatSingleValue(const bool &value) const
  97 {
  98     return value ? "yes" : "no";
  99 }
 100
 101 void BooleanOptionStorage::convertValue(const std::string &value)
 102 {
 103     // TODO: Case-independence
 104     if (value == "1" || value == "yes" || value == "true")
 105     {
 106         addValue(true);
 107         return;
 108     }
 109     else if (value == "0" || value == "no" || value == "false")
 110     {
 111         addValue(false);
 112         return;
 113     }
 114     GMX_THROW(InvalidInputError("Invalid value: '" + value + "'; supported values are: 1, 0, yes, no, true, false"));
 115 }
 116
 117 /********************************************************************
 118  * BooleanOptionInfo
 119  */
 120
 121 BooleanOptionInfo::BooleanOptionInfo(BooleanOptionStorage *option)
 122     : OptionInfo(option)
 123 {
 124 }
 125
 126 /********************************************************************
 127  * BooleanOption
 128  */
 129
 130 AbstractOptionStoragePointer BooleanOption::createStorage() const
 131 {
 132     return AbstractOptionStoragePointer(new BooleanOptionStorage(*this));
 133 }
 134
 135
 136 /********************************************************************
 137  * IntegerOptionStorage
 138  */
 139
 140 std::string IntegerOptionStorage::formatSingleValue(const int &value) const
 141 {
 142     return formatString("%d", value);
 143 }
 144
 145 void IntegerOptionStorage::convertValue(const std::string &value)
 146 {
 147     const char *ptr = value.c_str();
 148     char       *endptr;
 149     errno = 0;
 150     long int    ival = std::strtol(ptr, &endptr, 10);
 151     if (errno == ERANGE
 152         || ival < std::numeric_limits<int>::min()
 153         || ival > std::numeric_limits<int>::max())
 154     {
 155         GMX_THROW(InvalidInputError("Invalid value: '" + value
 156                                     + "'; it causes an integer overflow"));
 157     }
 158     if (*ptr == '\0' || *endptr != '\0')
 159     {
 160         GMX_THROW(InvalidInputError("Invalid value: '" + value
 161                                     + "'; expected an integer"));
 162     }
 163     addValue(ival);
 164 }
 165
 166 void IntegerOptionStorage::processSetValues(ValueList *values)
 167 {
 168     if (isVector())
 169     {
 170         expandVector(maxValueCount(), values);
 171     }
 172 }
 173
 174 /********************************************************************
 175  * IntegerOptionInfo
 176  */
 177
 178 IntegerOptionInfo::IntegerOptionInfo(IntegerOptionStorage *option)
 179     : OptionInfo(option)
 180 {
 181 }
 182
 183 /********************************************************************
 184  * IntegerOption
 185  */
 186
 187 AbstractOptionStoragePointer IntegerOption::createStorage() const
 188 {
 189     return AbstractOptionStoragePointer(new IntegerOptionStorage(*this));
 190 }
 191
 192
 193 /********************************************************************
 194  * DoubleOptionStorage
 195  */
 196
 197 DoubleOptionStorage::DoubleOptionStorage(const DoubleOption &settings)
 198     : MyBase(settings), info_(this), bTime_(settings.bTime_), factor_(1.0)
 199 {
 200 }
 201
 202 const char *DoubleOptionStorage::typeString() const
 203 {
 204     return isVector() ? "vector" : (isTime() ? "time" : "double");
 205 }
 206
 207 std::string DoubleOptionStorage::formatSingleValue(const double &value) const
 208 {
 209     return formatString("%g", value / factor_);
 210 }
 211
 212 void DoubleOptionStorage::convertValue(const std::string &value)
 213 {
 214     const char *ptr = value.c_str();
 215     char       *endptr;
 216     errno = 0;
 217     double      dval = std::strtod(ptr, &endptr);
 218     if (errno == ERANGE)
 219     {
 220         GMX_THROW(InvalidInputError("Invalid value: '" + value
 221                                     + "'; it causes an overflow/underflow"));
 222     }
 223     if (*ptr == '\0' || *endptr != '\0')
 224     {
 225         GMX_THROW(InvalidInputError("Invalid value: '" + value
 226                                     + "'; expected a number"));
 227     }
 228     addValue(dval * factor_);
 229 }
 230
 231 void DoubleOptionStorage::processSetValues(ValueList *values)
 232 {
 233     if (isVector())
 234     {
 235         expandVector(maxValueCount(), values);
 236     }
 237 }
 238
 239 void DoubleOptionStorage::processAll()
 240 {
 241 }
 242
 243 void DoubleOptionStorage::setScaleFactor(double factor)
 244 {
 245     GMX_RELEASE_ASSERT(factor > 0.0, "Invalid scaling factor");
 246     if (!hasFlag(efOption_HasDefaultValue))
 247     {
 248         double              scale = factor / factor_;
 249         ValueList::iterator i;
 250         for (i = values().begin(); i != values().end(); ++i)
 251         {
 252             (*i) *= scale;
 253         }
 254         refreshValues();
 255     }
 256     factor_ = factor;
 257 }
 258
 259 /********************************************************************
 260  * DoubleOptionInfo
 261  */
 262
 263 DoubleOptionInfo::DoubleOptionInfo(DoubleOptionStorage *option)
 264     : OptionInfo(option)
 265 {
 266 }
 267
 268 DoubleOptionStorage &DoubleOptionInfo::option()
 269 {
 270     return static_cast<DoubleOptionStorage &>(OptionInfo::option());
 271 }
 272
 273 const DoubleOptionStorage &DoubleOptionInfo::option() const
 274 {
 275     return static_cast<const DoubleOptionStorage &>(OptionInfo::option());
 276 }
 277
 278 bool DoubleOptionInfo::isTime() const
 279 {
 280     return option().isTime();
 281 }
 282
 283 void DoubleOptionInfo::setScaleFactor(double factor)
 284 {
 285     option().setScaleFactor(factor);
 286 }
 287
 288 /********************************************************************
 289  * DoubleOption
 290  */
 291
 292 AbstractOptionStoragePointer DoubleOption::createStorage() const
 293 {
 294     return AbstractOptionStoragePointer(new DoubleOptionStorage(*this));
 295 }
 296
 297
 298 /********************************************************************
 299  * StringOptionStorage
 300  */
 301
 302 StringOptionStorage::StringOptionStorage(const StringOption &settings)
 303     : MyBase(settings), info_(this), enumIndexStore_(NULL)
 304 {
 305     if (settings.defaultEnumIndex_ >= 0 && settings.enumValues_ == NULL)
 306     {
 307         GMX_THROW(APIError("Cannot set default enum index without enum values"));
 308     }
 309     if (settings.enumIndexStore_ != NULL && settings.enumValues_ == NULL)
 310     {
 311         GMX_THROW(APIError("Cannot set enum index store without enum values"));
 312     }
 313     if (settings.enumIndexStore_ != NULL && settings.maxValueCount_ < 0)
 314     {
 315         GMX_THROW(APIError("Cannot set enum index store with arbitrary number of values"));
 316     }
 317     if (settings.enumValues_ != NULL)
 318     {
 319         enumIndexStore_ = settings.enumIndexStore_;
 320         const std::string *defaultValue = settings.defaultValue();
 321         int                match        = -1;
 322         int                count        = settings.enumValuesCount_;
 323         if (count < 0)
 324         {
 325             count = 0;
 326             while (settings.enumValues_[count] != NULL)
 327             {
 328                 ++count;
 329             }
 330         }
 331         for (int i = 0; i < count; ++i)
 332         {
 333             if (settings.enumValues_[i] == NULL)
 334             {
 335                 GMX_THROW(APIError("Enumeration value cannot be NULL"));
 336             }
 337             if (defaultValue != NULL && settings.enumValues_[i] == *defaultValue)
 338             {
 339                 match = i;
 340             }
 341             allowed_.push_back(settings.enumValues_[i]);
 342         }
 343         if (defaultValue != NULL)
 344         {
 345             if (match < 0)
 346             {
 347                 GMX_THROW(APIError("Default value is not one of allowed values"));
 348             }
 349         }
 350         if (settings.defaultEnumIndex_ >= 0)
 351         {
 352             if (settings.defaultEnumIndex_ >= static_cast<int>(allowed_.size()))
 353             {
 354                 GMX_THROW(APIError("Default enumeration index is out of range"));
 355             }
 356             if (defaultValue != NULL && *defaultValue != allowed_[settings.defaultEnumIndex_])
 357             {
 358                 GMX_THROW(APIError("Conflicting default values"));
 359             }
 360         }
 361         // If there is no default value, match is still -1.
 362         if (enumIndexStore_ != NULL)
 363         {
 364             *enumIndexStore_ = match;
 365         }
 366     }
 367     if (settings.defaultEnumIndex_ >= 0)
 368     {
 369         clear();
 370         addValue(allowed_[settings.defaultEnumIndex_]);
 371         commitValues();
 372     }
 373 }
 374
 375 std::string StringOptionStorage::formatSingleValue(const std::string &value) const
 376 {
 377     return value;
 378 }
 379
 380 void StringOptionStorage::convertValue(const std::string &value)
 381 {
 382     if (allowed_.size() == 0)
 383     {
 384         addValue(value);
 385     }
 386     else
 387     {
 388         ValueList::const_iterator  i;
 389         ValueList::const_iterator  match = allowed_.end();
 390         for (i = allowed_.begin(); i != allowed_.end(); ++i)
 391         {
 392             // TODO: Case independence.
 393             if (i->find(value) == 0)
 394             {
 395                 if (match == allowed_.end() || i->size() < match->size())
 396                 {
 397                     match = i;
 398                 }
 399             }
 400         }
 401         if (match == allowed_.end())
 402         {
 403             GMX_THROW(InvalidInputError("Invalid value: " + value));
 404         }
 405         addValue(*match);
 406     }
 407 }
 408
 409 void StringOptionStorage::refreshValues()
 410 {
 411     MyBase::refreshValues();
 412     if (enumIndexStore_ != NULL)
 413     {
 414         for (size_t i = 0; i < values().size(); ++i)
 415         {
 416             ValueList::const_iterator match =
 417                 std::find(allowed_.begin(), allowed_.end(), values()[i]);
 418             GMX_ASSERT(match != allowed_.end(),
 419                        "Enum value not found (internal error)");
 420             enumIndexStore_[i] = static_cast<int>(match - allowed_.begin());
 421         }
 422     }
 423 }
 424
 425 /********************************************************************
 426  * StringOptionInfo
 427  */
 428
 429 StringOptionInfo::StringOptionInfo(StringOptionStorage *option)
 430     : OptionInfo(option)
 431 {
 432 }
 433
 434 StringOptionStorage &StringOptionInfo::option()
 435 {
 436     return static_cast<StringOptionStorage &>(OptionInfo::option());
 437 }
 438
 439 const StringOptionStorage &StringOptionInfo::option() const
 440 {
 441     return static_cast<const StringOptionStorage &>(OptionInfo::option());
 442 }
 443
 444 bool StringOptionInfo::isEnumerated() const
 445 {
 446     return !allowedValues().empty();
 447 }
 448
 449 const std::vector<std::string> &StringOptionInfo::allowedValues() const
 450 {
 451     return option().allowedValues();
 452 }
 453
 454 /********************************************************************
 455  * StringOption
 456  */
 457
 458 AbstractOptionStoragePointer StringOption::createStorage() const
 459 {
 460     return AbstractOptionStoragePointer(new StringOptionStorage(*this));
 461 }
 462
 463 } // namespace gmx