/*
* This file is part of the GROMACS molecular simulation package.
*
- * Copyright (c) 2012,2013,2014, by the GROMACS development team, led by
+ * Copyright (c) 2012,2013,2014,2015, by the GROMACS development team, led by
* Mark Abraham, David van der Spoel, Berk Hess, and Erik Lindahl,
* and including many others, as listed in the AUTHORS file in the
* top-level source directory and at http://www.gromacs.org.
bool bVersion_;
bool bCopyright_;
int niceLevel_;
+ bool bNiceSet_;
bool bBackup_;
bool bFpexcept_;
int debugLevel_;
CommandLineCommonOptionsHolder::CommandLineCommonOptionsHolder()
: options_(NULL, NULL), bHelp_(false), bHidden_(false),
bQuiet_(false), bVersion_(false), bCopyright_(true),
- niceLevel_(19), bBackup_(true), bFpexcept_(false), debugLevel_(0)
+ niceLevel_(19), bNiceSet_(false), bBackup_(true), bFpexcept_(false),
+ debugLevel_(0)
{
binaryInfoSettings_.copyright(true);
}
.description("Print extended version information and quit"));
options_.addOption(BooleanOption("copyright").store(&bCopyright_)
.description("Print copyright information on startup"));
- options_.addOption(IntegerOption("nice").store(&niceLevel_)
+ options_.addOption(IntegerOption("nice").store(&niceLevel_).storeIsSet(&bNiceSet_)
.description("Set the nicelevel (default depends on command)"));
options_.addOption(BooleanOption("backup").store(&bBackup_)
.description("Write backups if output files exist"));
void CommandLineCommonOptionsHolder::adjustFromSettings(
const CommandLineModuleSettings &settings)
{
- if (!options_.isSet("nice"))
+ if (!bNiceSet_)
{
niceLevel_ = settings.defaultNiceLevel();
}
parser.parse(&argc, argv);
options.finish();
}
- module_->optionsFinished(&options);
+ module_->optionsFinished();
}
} // namespace
/*! \brief
* Called after all option values have been set.
*
- * \param[in,out] options Options object in which options are stored.
- *
* When running the module, this method is called after all
- * command-line arguments have been parsed, but while the Options
- * object still exists.
+ * command-line arguments have been parsed.
*
- * If the module needs to call, e.g., Options::isSet(), this is the
- * place to do that.
+ * \todo
+ * Remove if no real need materializes.
*/
- virtual void optionsFinished(Options *options) = 0;
+ virtual void optionsFinished() = 0;
/*! \brief
* Runs the module.
try
{
- double tbegin = 0.0, tend = 0.0, tdelta = 0.0;
- bool bView = false;
- int xvgFormat = 0;
+ double tbegin = 0.0, tend = 0.0, tdelta = 0.0;
+ bool bBeginTimeSet = false, bEndTimeSet = false, bDtSet = false;
+ bool bView = false;
+ int xvgFormat = 0;
gmx::TimeUnitManager timeUnitManager;
gmx::OptionsAdapter adapter(*argc, argv);
gmx::Options options(NULL, NULL);
if (FF(PCA_CAN_BEGIN))
{
options.addOption(
- gmx::DoubleOption("b").store(&tbegin).timeValue()
+ gmx::DoubleOption("b")
+ .store(&tbegin).storeIsSet(&bBeginTimeSet).timeValue()
.description("First frame (%t) to read from trajectory"));
}
if (FF(PCA_CAN_END))
{
options.addOption(
- gmx::DoubleOption("e").store(&tend).timeValue()
+ gmx::DoubleOption("e")
+ .store(&tend).storeIsSet(&bEndTimeSet).timeValue()
.description("Last frame (%t) to read from trajectory"));
}
if (FF(PCA_CAN_DT))
{
options.addOption(
- gmx::DoubleOption("dt").store(&tdelta).timeValue()
+ gmx::DoubleOption("dt")
+ .store(&tdelta).storeIsSet(&bDtSet).timeValue()
.description("Only use frame when t MOD dt = first time (%t)"));
}
if (FF(PCA_TIME_UNIT))
timeUnitManager.scaleTimeOptions(&options);
/* Extract Time info from arguments */
- // TODO: Use OptionInfo objects instead of string constants
- if (FF(PCA_CAN_BEGIN) && options.isSet("b"))
+ if (bBeginTimeSet)
{
setTimeValue(TBEGIN, tbegin);
}
- if (FF(PCA_CAN_END) && options.isSet("e"))
+ if (bEndTimeSet)
{
setTimeValue(TEND, tend);
}
- if (FF(PCA_CAN_DT) && options.isSet("dt"))
+ if (bDtSet)
{
setTimeValue(TDELTA, tdelta);
}
MOCK_METHOD1(init, void(gmx::CommandLineModuleSettings *settings));
MOCK_METHOD2(initOptions, void(gmx::IOptionsContainer *options, gmx::ICommandLineOptionsModuleSettings *settings));
- MOCK_METHOD1(optionsFinished, void(gmx::Options *options));
+ MOCK_METHOD0(optionsFinished, void());
MOCK_METHOD0(run, int());
};
#include "gromacs/options/basicoptions.h"
#include "gromacs/options/filenameoption.h"
#include "gromacs/options/ioptionscontainer.h"
-#include "gromacs/options/options.h"
#include "gromacs/pbcutil/pbc.h"
#include "gromacs/random/random.h"
#include "gromacs/selection/nbsearch.h"
virtual void initOptions(IOptionsContainer *options,
ICommandLineOptionsModuleSettings *settings);
- virtual void optionsFinished(Options *options);
+ virtual void optionsFinished() {}
virtual int run();
.description("Output configuration after insertion"));
options->addOption(RealOption("box").vector()
- .store(newBox_)
+ .store(newBox_).storeIsSet(&bBox_)
.description("Box size (in nm)"));
options->addOption(IntegerOption("nmol")
.store(&nmolIns_)
.description("Rotate inserted molecules randomly"));
}
-void InsertMolecules::optionsFinished(Options *options)
-{
- bBox_ = options->isSet("box");
-}
-
int InsertMolecules::run()
{
const bool bProt = !inputConfFile_.empty();
/*
* This file is part of the GROMACS molecular simulation package.
*
- * Copyright (c) 2010,2011,2012,2013,2014, by the GROMACS development team, led by
+ * Copyright (c) 2010,2011,2012,2013,2014,2015, by the GROMACS development team, led by
* Mark Abraham, David van der Spoel, Berk Hess, and Erik Lindahl,
* and including many others, as listed in the AUTHORS file in the
* top-level source directory and at http://www.gromacs.org.
AbstractOptionStorage::AbstractOptionStorage(const AbstractOption &settings,
OptionFlags staticFlags)
: flags_(settings.flags_ | staticFlags),
+ storeIsSet_(settings.storeIsSet_),
minValueCount_(settings.minValueCount_),
maxValueCount_(settings.maxValueCount_),
bInSet_(false), bSetValuesHadErrors_(false)
{
descr_ = settings.descr_;
}
+ if (storeIsSet_ != NULL)
+ {
+ *storeIsSet_ = false;
+ }
setFlag(efOption_ClearOnNextSet);
}
}
}
+void AbstractOptionStorage::markAsSet()
+{
+ setFlag(efOption_Set);
+ if (storeIsSet_ != NULL)
+ {
+ *storeIsSet_ = true;
+ }
+}
+
void AbstractOptionStorage::finishSet()
{
GMX_RELEASE_ASSERT(bInSet_, "startSet() not called");
// We mark the option as set even when there are errors to avoid additional
// errors from required options not set.
// TODO: There could be a separate flag for this purpose.
- setFlag(efOption_Set);
+ markAsSet();
if (!bSetValuesHadErrors_)
{
// TODO: Correct handling of the efOption_ClearOnNextSet requires
//! Initializes the name and default values for an option.
explicit AbstractOption(const char *name)
: minValueCount_(1), maxValueCount_(1),
- name_(name), descr_(NULL)
+ name_(name), descr_(NULL), storeIsSet_(NULL)
{ }
/*! \brief
//! Sets the description for the option.
void setDescription(const char *descr) { descr_ = descr; }
+ //! Sets the storage location for whether the option is set.
+ void setStoreIsSet(bool *store) { storeIsSet_ = store; }
//! Sets a flag for the option.
void setFlag(OptionFlag flag) { flags_.set(flag); }
//! Clears a flag for the option.
//! Pointer to description of the option.
const char *descr_;
OptionFlags flags_;
+ bool *storeIsSet_;
/*! \brief
* Needed to initialize an AbstractOptionStorage object from this class
*/
MyClass &storeVector(std::vector<T> *store)
{ storeVector_ = store; return me(); }
+ /*! \brief
+ * Stores whether the option was explicitly set.
+ *
+ * \param[in] store Variable to store the flag in.
+ *
+ * The value is set to `false` on creation of the option, and to `true`
+ * as soon as a value is assigned to the option. A default value does
+ * not set the flag to `true`, but assignment that uses
+ * defaultValueIfSet() does.
+ *
+ * The pointer provided should remain valid as long as the associated
+ * Options object exists.
+ */
+ MyClass &storeIsSet(bool *store)
+ { setStoreIsSet(store); return me(); }
protected:
/*! \cond libapi */
/*
* This file is part of the GROMACS molecular simulation package.
*
- * Copyright (c) 2010,2011,2012,2014, by the GROMACS development team, led by
+ * Copyright (c) 2010,2011,2012,2014,2015, by the GROMACS development team, led by
* Mark Abraham, David van der Spoel, Berk Hess, and Erik Lindahl,
* and including many others, as listed in the AUTHORS file in the
* top-level source directory and at http://www.gromacs.org.
OptionFlags staticFlags);
//! Marks the option as set.
- void markAsSet() { flags_.set(efOption_Set); }
+ void markAsSet();
//! Returns true if the given flag is set.
bool hasFlag(OptionFlag flag) const { return flags_.test(flag); }
//! Sets the given flag.
std::string descr_;
//! Flags for the option.
OptionFlags flags_;
+ bool *storeIsSet_;
//! Minimum number of values required (in one set).
int minValueCount_;
//! Maximum allowed number of values (in one set), or -1 if no limit.
return impl_->rootGroup_.addOption(settings);
}
-bool Options::isSet(const char *name) const
-{
- AbstractOptionStorage *option = impl_->findOption(name);
- return (option != NULL ? option->isSet() : false);
-}
-
void Options::finish()
{
// TODO: Consider how to customize these error messages based on context.
virtual OptionInfo *addOption(const AbstractOption &settings);
using IOptionsContainer::addOption;
- //! Returns true if option \p name is set.
- bool isSet(const char *name) const;
/*! \brief
* Notifies the collection that all option values are assigned.
*
#include "gromacs/utility/exceptions.h"
#include "gromacs/utility/stringutil.h"
+#include "testutils/testasserts.h"
+
namespace
{
{
gmx::Options options(NULL, NULL);
std::vector<int> values;
+ bool bIsSet;
using gmx::IntegerOption;
ASSERT_NO_THROW(options.addOption(
- IntegerOption("p").storeVector(&values).multiValue()));
+ IntegerOption("p")
+ .storeVector(&values).storeIsSet(&bIsSet)
+ .multiValue()));
gmx::OptionsAssigner assigner(&options);
EXPECT_NO_THROW(assigner.start());
EXPECT_NO_THROW(assigner.finish());
EXPECT_NO_THROW(options.finish());
- EXPECT_TRUE(options.isSet("p"));
+ EXPECT_TRUE(bIsSet);
ASSERT_EQ(1U, values.size());
EXPECT_EQ(1, values[0]);
}
{
gmx::Options options(NULL, NULL);
std::vector<int> values;
+ bool bIsSet;
using gmx::IntegerOption;
ASSERT_NO_THROW(options.addOption(
- IntegerOption("p").storeVector(&values).allowMultiple()));
-
- gmx::OptionsAssigner assigner(&options);
- EXPECT_NO_THROW(assigner.start());
- ASSERT_NO_THROW(assigner.startOption("p"));
- ASSERT_NO_THROW(assigner.appendValue("1"));
- EXPECT_NO_THROW(assigner.finishOption());
- ASSERT_NO_THROW(assigner.startOption("p"));
- ASSERT_NO_THROW(assigner.appendValue("2"));
- EXPECT_NO_THROW(assigner.finishOption());
- EXPECT_NO_THROW(assigner.finish());
- EXPECT_NO_THROW(options.finish());
-
- EXPECT_TRUE(options.isSet("p"));
+ IntegerOption("p")
+ .storeVector(&values).storeIsSet(&bIsSet)
+ .allowMultiple()));
+
+ gmx::OptionsAssigner assigner(&options);
+ EXPECT_NO_THROW_GMX(assigner.start());
+ ASSERT_NO_THROW_GMX(assigner.startOption("p"));
+ ASSERT_NO_THROW_GMX(assigner.appendValue("1"));
+ EXPECT_NO_THROW_GMX(assigner.finishOption());
+ ASSERT_NO_THROW_GMX(assigner.startOption("p"));
+ ASSERT_NO_THROW_GMX(assigner.appendValue("2"));
+ EXPECT_NO_THROW_GMX(assigner.finishOption());
+ EXPECT_NO_THROW_GMX(assigner.finish());
+ EXPECT_NO_THROW_GMX(options.finish());
+
+ EXPECT_TRUE(bIsSet);
ASSERT_EQ(2U, values.size());
EXPECT_EQ(1, values[0]);
EXPECT_EQ(2, values[1]);
/*
* This file is part of the GROMACS molecular simulation package.
*
- * Copyright (c) 2010,2011,2012,2013,2014, by the GROMACS development team, led by
+ * Copyright (c) 2010,2011,2012,2013,2014,2015, by the GROMACS development team, led by
* Mark Abraham, David van der Spoel, Berk Hess, and Erik Lindahl,
* and including many others, as listed in the AUTHORS file in the
* top-level source directory and at http://www.gromacs.org.
void TrajectoryAnalysisModule::optionsFinished(
- Options * /*options*/,
TrajectoryAnalysisSettings * /*settings*/)
{
}
/*! \brief
* Called after all option values have been set.
*
- * \param[in,out] options Options object in which options are stored.
* \param[in,out] settings Settings to pass to and from the module.
*
* This method is called after option values have been assigned (but
*
* The default implementation does nothing.
*/
- virtual void optionsFinished(Options *options,
- TrajectoryAnalysisSettings *settings);
+ virtual void optionsFinished(TrajectoryAnalysisSettings *settings);
/*! \brief
* Initializes the analysis.
*
options.finish();
}
- common->optionsFinished(&options);
- module_->optionsFinished(&options, settings);
+ common->optionsFinished();
+ module_->optionsFinished(settings);
common->initIndexGroups(selections, bUseDefaultGroups_);
#include "gromacs/options/basicoptions.h"
#include "gromacs/options/filenameoption.h"
#include "gromacs/options/ioptionscontainer.h"
-#include "gromacs/options/options.h"
#include "gromacs/pbcutil/pbc.h"
#include "gromacs/selection/selection.h"
#include "gromacs/selection/selectionoption.h"
virtual void initOptions(IOptionsContainer *options,
TrajectoryAnalysisSettings *settings);
- virtual void optionsFinished(Options *options,
- TrajectoryAnalysisSettings *settings);
+ virtual void optionsFinished(TrajectoryAnalysisSettings *settings);
virtual void initAnalysis(const TrajectoryAnalysisSettings &settings,
const TopologyInformation &top);
void
-Angle::optionsFinished(Options *options, TrajectoryAnalysisSettings * /* settings */)
+Angle::optionsFinished(TrajectoryAnalysisSettings * /* settings */)
{
const bool bSingle = (g1type_[0] == 'a' || g1type_[0] == 'd');
GMX_THROW(InconsistentInputError("Cannot use a second group (-g2) with "
"-g1 angle or dihedral"));
}
- if (bSingle && options->isSet("group2"))
+ if (bSingle && sel2info_->isSet())
{
GMX_THROW(InconsistentInputError("Cannot provide a second selection "
"(-group2) with -g1 angle or dihedral"));
default:
GMX_THROW(InternalError("invalid -g2 value"));
}
- if (natoms2_ == 0 && options->isSet("group2"))
+ if (natoms2_ == 0 && sel2info_->isSet())
{
GMX_THROW(InconsistentInputError("Cannot provide a second selection (-group2) with -g2 t0 or z"));
}
#include "gromacs/options/basicoptions.h"
#include "gromacs/options/filenameoption.h"
#include "gromacs/options/ioptionscontainer.h"
-#include "gromacs/options/options.h"
#include "gromacs/pbcutil/pbc.h"
#include "gromacs/selection/nbsearch.h"
#include "gromacs/selection/selection.h"
virtual void initOptions(IOptionsContainer *options,
TrajectoryAnalysisSettings *settings);
- virtual void optionsFinished(Options *options,
- TrajectoryAnalysisSettings *settings);
+ virtual void optionsFinished(TrajectoryAnalysisSettings *settings);
virtual void initAnalysis(const TrajectoryAnalysisSettings &settings,
const TopologyInformation &top);
virtual void initAfterFirstFrame(const TrajectoryAnalysisSettings &settings,
double cutoff_;
double rmax_;
bool bNormalize_;
+ bool bNormalizationSet_;
bool bXY_;
bool bExclusions_;
pairCounts_(new AnalysisDataSimpleHistogramModule()),
normAve_(new AnalysisDataAverageModule()),
binwidth_(0.002), cutoff_(0.0), rmax_(0.0),
- bNormalize_(true), bXY_(false), bExclusions_(false),
+ bNormalize_(true), bNormalizationSet_(false), bXY_(false),
+ bExclusions_(false),
cut2_(0.0), rmax2_(0.0), surfaceGroupCount_(0)
{
pairDist_.setMultipoint(true);
options->addOption(DoubleOption("bin").store(&binwidth_)
.description("Bin width (nm)"));
options->addOption(BooleanOption("norm").store(&bNormalize_)
+ .storeIsSet(&bNormalizationSet_)
.description("Normalize for bin volume and density"));
options->addOption(BooleanOption("xy").store(&bXY_)
.description("Use only the x and y components of the distance"));
}
void
-Rdf::optionsFinished(Options *options, TrajectoryAnalysisSettings *settings)
+Rdf::optionsFinished(TrajectoryAnalysisSettings *settings)
{
if (surface_ != "no")
{
settings->setFlag(TrajectoryAnalysisSettings::efRequireTop);
- if (options->isSet("norm") && bNormalize_)
+ if (bNormalizationSet_ && bNormalize_)
{
GMX_THROW(InconsistentInputError("-surf cannot be combined with -norm"));
}
virtual void initOptions(IOptionsContainer *options,
TrajectoryAnalysisSettings *settings);
- virtual void optionsFinished(Options *options,
- TrajectoryAnalysisSettings *settings);
+ virtual void optionsFinished(TrajectoryAnalysisSettings *settings);
virtual void initAnalysis(const TrajectoryAnalysisSettings &settings,
const TopologyInformation &top);
}
void
-Select::optionsFinished(Options * /*options*/,
- TrajectoryAnalysisSettings *settings)
+Select::optionsFinished(TrajectoryAnalysisSettings *settings)
{
if (!fnPDB_.empty())
{
double startTime_;
double endTime_;
double deltaTime_;
+ bool bStartTimeSet_;
+ bool bEndTimeSet_;
+ bool bDeltaTimeSet_;
gmx_ana_indexgrps_t *grps_;
bool bTrajOpen_;
TrajectoryAnalysisRunnerCommon::Impl::Impl(TrajectoryAnalysisSettings *settings)
: settings_(*settings),
startTime_(0.0), endTime_(0.0), deltaTime_(0.0),
+ bStartTimeSet_(false), bEndTimeSet_(false), bDeltaTimeSet_(false),
grps_(NULL),
bTrajOpen_(false), fr(NULL), gpbc_(NULL), status_(NULL), oenv_(NULL)
{
.description("Extra index groups"));
// Add options for trajectory time control.
- options->addOption(DoubleOption("b").store(&impl_->startTime_).timeValue()
+ options->addOption(DoubleOption("b")
+ .store(&impl_->startTime_).storeIsSet(&impl_->bStartTimeSet_)
+ .timeValue()
.description("First frame (%t) to read from trajectory"));
- options->addOption(DoubleOption("e").store(&impl_->endTime_).timeValue()
+ options->addOption(DoubleOption("e")
+ .store(&impl_->endTime_).storeIsSet(&impl_->bEndTimeSet_)
+ .timeValue()
.description("Last frame (%t) to read from trajectory"));
- options->addOption(DoubleOption("dt").store(&impl_->deltaTime_).timeValue()
+ options->addOption(DoubleOption("dt")
+ .store(&impl_->deltaTime_).storeIsSet(&impl_->bDeltaTimeSet_)
+ .timeValue()
.description("Only use frame if t MOD dt == first time (%t)"));
// Add time unit option.
void
-TrajectoryAnalysisRunnerCommon::optionsFinished(Options *options)
+TrajectoryAnalysisRunnerCommon::optionsFinished()
{
impl_->settings_.impl_->plotSettings.setTimeUnit(
impl_->settings_.impl_->timeUnitManager.timeUnit());
GMX_THROW(InconsistentInputError("No trajectory or topology provided, nothing to do!"));
}
- if (options->isSet("b"))
+ if (impl_->bStartTimeSet_)
{
setTimeValue(TBEGIN, impl_->startTime_);
}
- if (options->isSet("e"))
+ if (impl_->bEndTimeSet_)
{
setTimeValue(TEND, impl_->endTime_);
}
- if (options->isSet("dt"))
+ if (impl_->bDeltaTimeSet_)
{
setTimeValue(TDELTA, impl_->deltaTime_);
}
void initOptions(IOptionsContainer *options);
//! Scales time option values according to the time unit set.
void scaleTimeOptions(Options *options);
- /*! \brief
- * Processes common option values after they have been parsed.
- *
- * \param[in,out] options Options object in which options are stored.
- */
- void optionsFinished(Options *options);
+ //! Processes common option values after they have been parsed.
+ void optionsFinished();
//! Initialize index groups for selections.
void initIndexGroups(SelectionCollection *selections,
bool bUseDefaults);
#include <libxml/xmlmemory.h>
#include "gromacs/options/basicoptions.h"
-#include "gromacs/options/options.h"
+#include "gromacs/options/ioptionscontainer.h"
#include "gromacs/utility/exceptions.h"
#include "gromacs/utility/gmxassert.h"
#include "gromacs/utility/path.h"
namespace test
{
-void initReferenceData(Options *options)
+void initReferenceData(IOptionsContainer *options)
{
// Needs to correspond to the enum order in refdata.h.
const char *const refDataEnum[] = { "check", "create", "update" };
namespace gmx
{
-class Options;
+class IOptionsContainer;
namespace test
{
*
* \ingroup module_testutils
*/
-void initReferenceData(Options *options);
+void initReferenceData(IOptionsContainer *options);
class TestReferenceChecker;
biod.pnpi.spb.ru / alexxy / gromacs.git / commitdiff