formatter_.clear();
std::string name(formatString("-%s", option.name().c_str()));
formatter_.addColumnLine(0, name);
- for (int i = 0; i < option.valueCount(); ++i)
+ for (int i = 0; i < option.valueCount() || i == 0; ++i)
{
- std::string value(option.formatValue(i));
+ std::string value;
+ if (option.valueCount() == 0)
+ {
+ value = option.formatDefaultValueIfSet();
+ }
+ else
+ {
+ value = option.formatValue(i);
+ }
formatter_.addColumnLine(1, value);
if (value.length() > 12U && i == firstShortValue)
{
Option Filename Type Description
---------------------------------------------------------
-f traj Input Input file description
--lib Input, Opt., Lib.
+-lib libdata Input, Opt., Lib.
Library file description
-io In/Out, Opt. Input/Output file description
-o Output, Opt. Output file description
return option().formatValue(i);
}
+std::string OptionInfo::formatDefaultValueIfSet() const
+{
+ return option().formatDefaultValueIfSet();
+}
+
} // namespace gmx
virtual int valueCount() const = 0;
/*! \brief
* Returns the i'th value formatted as a string.
+ *
+ * If \p i is DefaultValueIfSetIndex, should format the default value
+ * if set (see OptionTemplate::defaultValueIfSet()).
*/
virtual std::string formatValue(int i) const = 0;
+ //! \copydoc OptionInfo::formatDefaultValueIfSet()
+ std::string formatDefaultValueIfSet() const
+ { return formatValue(DefaultValueIfSetIndex); }
/*! \brief
* Starts adding values from a new source for the option.
void finish();
protected:
+ //! Index used with formatValue() for formatting default value if set.
+ static const int DefaultValueIfSetIndex = -1;
+
/*! \brief
* Initializes the storage object from the settings object.
*
* BooleanOptionStorage
*/
-std::string BooleanOptionStorage::formatValue(int i) const
+std::string BooleanOptionStorage::formatSingleValue(const bool &value) const
{
- bool value = values()[i];
return value ? "yes" : "no";
}
* IntegerOptionStorage
*/
-std::string IntegerOptionStorage::formatValue(int i) const
+std::string IntegerOptionStorage::formatSingleValue(const int &value) const
{
- int value = values()[i];
return formatString("%d", value);
}
return hasFlag(efVector) ? "vector" : (isTime() ? "time" : "double");
}
-std::string DoubleOptionStorage::formatValue(int i) const
+std::string DoubleOptionStorage::formatSingleValue(const double &value) const
{
- return formatString("%g", values()[i] / factor_);
+ return formatString("%g", value / factor_);
}
void DoubleOptionStorage::convertValue(const std::string &value)
}
}
-std::string StringOptionStorage::formatValue(int i) const
+std::string StringOptionStorage::formatSingleValue(const std::string &value) const
{
- return values()[i];
+ return value;
}
void StringOptionStorage::convertValue(const std::string &value)
virtual OptionInfo &optionInfo() { return info_; }
virtual const char *typeString() const { return "bool"; }
- virtual std::string formatValue(int i) const;
+ virtual std::string formatSingleValue(const bool &value) const;
private:
virtual void convertValue(const std::string &value);
virtual OptionInfo &optionInfo() { return info_; }
virtual const char *typeString() const
{ return hasFlag(efVector) ? "vector" : "int"; }
- virtual std::string formatValue(int i) const;
+ virtual std::string formatSingleValue(const int &value) const;
private:
virtual void convertValue(const std::string &value);
virtual OptionInfo &optionInfo() { return info_; }
virtual const char *typeString() const;
- virtual std::string formatValue(int i) const;
+ virtual std::string formatSingleValue(const double &value) const;
//! \copydoc DoubleOptionInfo::isTime()
bool isTime() const { return bTime_; }
virtual OptionInfo &optionInfo() { return _info; }
virtual const char *typeString() const { return _allowed.empty() ? "string" : "enum"; }
- virtual std::string formatValue(int i) const;
+ virtual std::string formatSingleValue(const std::string &value) const;
private:
virtual void convertValue(const std::string &value);
{
}
-std::string FileNameOptionStorage::formatValue(int i) const
+std::string FileNameOptionStorage::formatSingleValue(const std::string &value) const
{
- return values()[i];
+ return value;
}
void FileNameOptionStorage::convertValue(const std::string &value)
virtual OptionInfo &optionInfo() { return info_; }
virtual const char *typeString() const { return "file"; }
- virtual std::string formatValue(int i) const;
+ virtual std::string formatSingleValue(const std::string &value) const;
//! \copydoc FileNameOptionInfo::isInputFile()
bool isInputFile() const { return bRead_ && !bWrite_; }
int valueCount() const;
//! Returns the i'th value of the option as a string.
std::string formatValue(int i) const;
+ /*! \brief
+ * Returns the default value if set for the option as a string.
+ *
+ * \see OptionTemplate::defaultValueIfSet()
+ */
+ std::string formatDefaultValueIfSet() const;
protected:
/*! \cond libapi */
// the declarations are still included for clarity.
virtual const char *typeString() const = 0;
virtual int valueCount() const { return static_cast<int>(_values->size()); }
- virtual std::string formatValue(int i) const = 0;
+ /*! \copydoc AbstractOptionStorage::formatValue()
+ *
+ * OptionStorageTemplate implements handling of DefaultValueIfSetIndex
+ * in this method, as well as checking that \p i is a valid index.
+ * Derived classes must implement formatSingleValue() to provide the
+ * actual formatting for a value of type \p T.
+ */
+ virtual std::string formatValue(int i) const;
protected:
/*! \brief
}
/*! \copydoc AbstractOptionStorage::processSet()
*
- * OptionStorage template implements transaction support for a set of
+ * OptionStorageTemplate implements transaction support for a set of
* values in this method (see the class description), and provides a
* more detailed processSetValues() method that can be overridden in
* subclasses to process the actual values. Derived classes should
virtual void processAll()
{
}
+ /*! \brief
+ * Formats a single value as a string.
+ *
+ * \param[in] value Value to format.
+ * \returns \p value formatted as a string.
+ *
+ * The derived class must provide this method to format values a
+ * strings. Called by formatValue() to do the actual formatting.
+ */
+ virtual std::string formatSingleValue(const T &value) const = 0;
/*! \brief
* Removes all values from the storage.
}
+template <typename T>
+std::string OptionStorageTemplate<T>::formatValue(int i) const
+{
+ GMX_RELEASE_ASSERT(i == DefaultValueIfSetIndex || (i >= 0 && i < valueCount()),
+ "Invalid value index");
+ if (i == DefaultValueIfSetIndex)
+ {
+ if (_defaultValueIfSet.get() != NULL)
+ {
+ return formatSingleValue(*_defaultValueIfSet);
+ }
+ return std::string();
+ }
+ return formatSingleValue(values()[i]);
+}
+
+
template <typename T>
void OptionStorageTemplate<T>::clearSet()
{
GMX_THROW(gmx::test::TestException("Not implemented"));
}
virtual const char *typeString() const { return "mock"; }
- virtual std::string formatValue(int /*i*/) const { return ""; }
+ virtual std::string formatSingleValue(const std::string &/*value*/) const
+ {
+ return "";
+ }
MOCK_METHOD1(convertValue, void(const std::string &value));
MOCK_METHOD1(processSetValues, void(ValueList *values));
}
-std::string SelectionOptionStorage::formatValue(int i) const
+std::string SelectionOptionStorage::formatSingleValue(const Selection &value) const
{
- return values()[i].selectionText();
+ return value.selectionText();
}
virtual OptionInfo &optionInfo() { return _info; }
virtual const char *typeString() const { return "sel"; }
- virtual std::string formatValue(int i) const;
+ virtual std::string formatSingleValue(const Selection &value) const;
//! \copydoc SelectionOptionInfo::setSelectionCollection()
void setSelectionCollection(SelectionCollection *selections)