Settings module do not need settings manager

Former-commit-id: b26ccc902d

src/settings/SettingsManager.cpp

@@ -35,19 +35,19 @@ namespace storm {
         
         SettingsManager::SettingsManager() : modules(), longNameToOptions(), shortNameToOptions(), moduleOptions() {
             // Register all known settings modules.
-            this->addModule(std::unique_ptr<modules::ModuleSettings>(new modules::GeneralSettings(*this)));
-            this->addModule(std::unique_ptr<modules::ModuleSettings>(new modules::DebugSettings(*this)));
-            this->addModule(std::unique_ptr<modules::ModuleSettings>(new modules::CounterexampleGeneratorSettings(*this)));
-            this->addModule(std::unique_ptr<modules::ModuleSettings>(new modules::CuddSettings(*this)));
-            this->addModule(std::unique_ptr<modules::ModuleSettings>(new modules::SylvanSettings(*this)));
-            this->addModule(std::unique_ptr<modules::ModuleSettings>(new modules::GmmxxEquationSolverSettings(*this)));
-            this->addModule(std::unique_ptr<modules::ModuleSettings>(new modules::NativeEquationSolverSettings(*this)));
-            this->addModule(std::unique_ptr<modules::ModuleSettings>(new modules::BisimulationSettings(*this)));
-            this->addModule(std::unique_ptr<modules::ModuleSettings>(new modules::GlpkSettings(*this)));
-			this->addModule(std::unique_ptr<modules::ModuleSettings>(new modules::GurobiSettings(*this)));
-			this->addModule(std::unique_ptr<modules::ModuleSettings>(new modules::TopologicalValueIterationEquationSolverSettings(*this)));
-            this->addModule(std::unique_ptr<modules::ModuleSettings>(new modules::ParametricSettings(*this)));
-            this->addModule(std::unique_ptr<modules::ModuleSettings>(new modules::SparseDtmcEliminationModelCheckerSettings(*this)));
+            this->addModule(std::unique_ptr<modules::ModuleSettings>(new modules::GeneralSettings()));
+            this->addModule(std::unique_ptr<modules::ModuleSettings>(new modules::DebugSettings()));
+            this->addModule(std::unique_ptr<modules::ModuleSettings>(new modules::CounterexampleGeneratorSettings()));
+            this->addModule(std::unique_ptr<modules::ModuleSettings>(new modules::CuddSettings()));
+            this->addModule(std::unique_ptr<modules::ModuleSettings>(new modules::SylvanSettings()));
+            this->addModule(std::unique_ptr<modules::ModuleSettings>(new modules::GmmxxEquationSolverSettings()));
+            this->addModule(std::unique_ptr<modules::ModuleSettings>(new modules::NativeEquationSolverSettings()));
+            this->addModule(std::unique_ptr<modules::ModuleSettings>(new modules::BisimulationSettings()));
+            this->addModule(std::unique_ptr<modules::ModuleSettings>(new modules::GlpkSettings()));
+            this->addModule(std::unique_ptr<modules::ModuleSettings>(new modules::GurobiSettings()));
+            this->addModule(std::unique_ptr<modules::ModuleSettings>(new modules::TopologicalValueIterationEquationSolverSettings()));
+            this->addModule(std::unique_ptr<modules::ModuleSettings>(new modules::ParametricSettings()));
+            this->addModule(std::unique_ptr<modules::ModuleSettings>(new modules::SparseDtmcEliminationModelCheckerSettings()));
         }
         
         SettingsManager::~SettingsManager() {

src/settings/modules/BisimulationSettings.cpp

@@ -13,7 +13,7 @@ namespace storm {
             const std::string BisimulationSettings::moduleName = "bisimulation";
             const std::string BisimulationSettings::typeOptionName = "type";
             
-            BisimulationSettings::BisimulationSettings(storm::settings::SettingsManager& settingsManager) : ModuleSettings(settingsManager, moduleName) {
+            BisimulationSettings::BisimulationSettings() : ModuleSettings(moduleName) {
                 std::vector<std::string> types = { "strong", "weak" };
                 this->addOption(storm::settings::OptionBuilder(moduleName, typeOptionName, true, "Sets the kind of bisimulation quotienting used. Available are: { strong, weak }.").addArgument(storm::settings::ArgumentBuilder::createStringArgument("name", "The name of the type to use.").addValidationFunctionString(storm::settings::ArgumentValidators::stringInListValidator(types)).setDefaultValueString("strong").build()).build());
             }

src/settings/modules/BisimulationSettings.h

@@ -16,11 +16,9 @@ namespace storm {
                 enum class BisimulationType { Strong, Weak };
                 
                 /*!
-                 * Creates a new set of bisimulation settings that is managed by the given manager.
-                 *
-                 * @param settingsManager The responsible manager.
+                 * Creates a new set of bisimulation settings.
                  */
-                BisimulationSettings(storm::settings::SettingsManager& settingsManager);
+                BisimulationSettings();
                 
                 /*!
                  * Retrieves whether strong bisimulation is to be used.

src/settings/modules/CounterexampleGeneratorSettings.cpp

@@ -17,7 +17,7 @@ namespace storm {
             const std::string CounterexampleGeneratorSettings::encodeReachabilityOptionName = "encreach";
             const std::string CounterexampleGeneratorSettings::schedulerCutsOptionName = "schedcuts";
             
-            CounterexampleGeneratorSettings::CounterexampleGeneratorSettings(storm::settings::SettingsManager& settingsManager) : ModuleSettings(settingsManager, moduleName) {
+            CounterexampleGeneratorSettings::CounterexampleGeneratorSettings() : ModuleSettings(moduleName) {
                 std::vector<std::string> techniques = {"maxsat", "milp"};
                 this->addOption(storm::settings::OptionBuilder(moduleName, minimalCommandSetOptionName, true, "Computes a counterexample for the given model in terms of a minimal command set. Note that this requires the model to be given in a symbolic format.")
                                 .addArgument(storm::settings::ArgumentBuilder::createStringArgument("method", "Sets which technique is used to derive the counterexample. Available are {milp, maxsat}").setDefaultValueString("maxsat").addValidationFunctionString(storm::settings::ArgumentValidators::stringInListValidator(techniques)).build()).build());

src/settings/modules/CounterexampleGeneratorSettings.h

@@ -13,11 +13,9 @@ namespace storm {
             class CounterexampleGeneratorSettings : public ModuleSettings {
             public:
                 /*!
-                 * Creates a new set of counterexample settings that is managed by the given manager.
-                 *
-                 * @param settingsManager The responsible manager.
+                 * Creates a new set of counterexample settings.
                  */
-                CounterexampleGeneratorSettings(storm::settings::SettingsManager& settingsManager);
+                CounterexampleGeneratorSettings();
                 
                 /*!
                  * Retrieves whether the option to generate a minimal command set was set.

src/settings/modules/CuddSettings.cpp

@@ -16,7 +16,7 @@ namespace storm {
             const std::string CuddSettings::maximalMemoryOptionName = "maxmem";
             const std::string CuddSettings::reorderOptionName = "reorder";
             
-            CuddSettings::CuddSettings(storm::settings::SettingsManager& settingsManager) : ModuleSettings(settingsManager, moduleName) {
+            CuddSettings::CuddSettings() : ModuleSettings(moduleName) {
                 this->addOption(storm::settings::OptionBuilder(moduleName, precisionOptionName, true, "Sets the precision used by Cudd.").addArgument(storm::settings::ArgumentBuilder::createDoubleArgument("value", "The precision up to which to constants are considered to be different.").setDefaultValueDouble(1e-15).addValidationFunctionDouble(storm::settings::ArgumentValidators::doubleRangeValidatorExcluding(0.0, 1.0)).build()).build());
                 
                 this->addOption(storm::settings::OptionBuilder(moduleName, maximalMemoryOptionName, true, "Sets the upper bound of memory available to Cudd in MB.").addArgument(storm::settings::ArgumentBuilder::createUnsignedIntegerArgument("value", "The memory available to Cudd (0 means unlimited).").setDefaultValueUnsignedInteger(4096).build()).build());

src/settings/modules/CuddSettings.h

@@ -16,11 +16,9 @@ namespace storm {
                 enum class ReorderingTechnique { None, Random, RandomPivot, Sift, SiftConv, SymmetricSift, SymmetricSiftConv, GroupSift, GroupSiftConv, Win2, Win2Conv, Win3, Win3Conv, Win4, Win4Conv, Annealing, Genetic, Exact };
                 
                 /*!
-                 * Creates a new set of CUDD settings that is managed by the given manager.
-                 *
-                 * @param settingsManager The responsible manager.
+                 * Creates a new set of CUDD settings.
                  */
-                CuddSettings(storm::settings::SettingsManager& settingsManager);
+                CuddSettings();
                 
                 /*!
                  * Retrieves the precision that CUDD is supposed to use for distinguishing constants.

src/settings/modules/DebugSettings.cpp

@@ -16,7 +16,7 @@ namespace storm {
             const std::string DebugSettings::logfileOptionName = "logfile";
             const std::string DebugSettings::logfileOptionShortName = "l";
  
-            DebugSettings::DebugSettings(storm::settings::SettingsManager& settingsManager) : ModuleSettings(settingsManager, moduleName) {
+            DebugSettings::DebugSettings() : ModuleSettings(moduleName) {
                 this->addOption(storm::settings::OptionBuilder(moduleName, debugOptionName, false, "Print debug output.").build());
                 this->addOption(storm::settings::OptionBuilder(moduleName, traceOptionName, false, "Print even more debug output.").build());
                 this->addOption(storm::settings::OptionBuilder(moduleName, logfileOptionName, false, "If specified, the log output will also be written to this file.").setShortName(logfileOptionShortName)

src/settings/modules/DebugSettings.h

@@ -13,11 +13,9 @@ namespace storm {
             class DebugSettings : public ModuleSettings {
             public:
                 /*!
-                 * Creates a new set of debug settings that is managed by the given manager.
-                 *
-                 * @param settingsManager The responsible manager.
+                 * Creates a new set of debug settings.
                  */
-                DebugSettings(storm::settings::SettingsManager& settingsManager);
+                DebugSettings();
                 
                 /*!
                  * Retrieves whether the debug option was set.

src/settings/modules/GeneralSettings.cpp

@@ -66,7 +66,7 @@ namespace storm {
             const std::string GeneralSettings::parametricOptionName = "parametric";
 #endif
 
-            GeneralSettings::GeneralSettings(storm::settings::SettingsManager& settingsManager) : ModuleSettings(settingsManager, moduleName) {
+            GeneralSettings::GeneralSettings() : ModuleSettings(moduleName) {
                 this->addOption(storm::settings::OptionBuilder(moduleName, helpOptionName, false, "Shows all available options, arguments and descriptions.").setShortName(helpOptionShortName)
                                 .addArgument(storm::settings::ArgumentBuilder::createStringArgument("hint", "A regular expression to show help for all matching entities or 'all' for the complete help.").setDefaultValueString("all").build()).build());
                 this->addOption(storm::settings::OptionBuilder(moduleName, prismCompatibilityOptionName, false, "Enables PRISM compatibility. This may be necessary to process some PRISM models.").setShortName(prismCompatibilityOptionShortName).build());

src/settings/modules/GeneralSettings.h

@@ -32,11 +32,9 @@ namespace storm {
                 };
 
                 /*!
-                 * Creates a new set of general settings that is managed by the given manager.
-                 *
-                 * @param settingsManager The responsible manager.
+                 * Creates a new set of general settings.
                  */
-                GeneralSettings(storm::settings::SettingsManager& settingsManager);
+                GeneralSettings();
 
                 /*!
                  * Retrieves whether the help option was set.

src/settings/modules/GlpkSettings.cpp

@@ -16,7 +16,7 @@ namespace storm {
             const std::string GlpkSettings::integerToleranceOption = "inttol";
             const std::string GlpkSettings::outputOptionName = "output";
             
-            GlpkSettings::GlpkSettings(storm::settings::SettingsManager& settingsManager) : ModuleSettings(settingsManager, moduleName) {
+            GlpkSettings::GlpkSettings() : ModuleSettings(moduleName) {
                 this->addOption(storm::settings::OptionBuilder(moduleName, outputOptionName, true, "If set, the glpk output will be printed to the command line.").build());
                 this->addOption(storm::settings::OptionBuilder(moduleName, integerToleranceOption, true, "Sets glpk's precision for integer variables.").addArgument(storm::settings::ArgumentBuilder::createDoubleArgument("value", "The precision to achieve.").setDefaultValueDouble(1e-06).addValidationFunctionDouble(storm::settings::ArgumentValidators::doubleRangeValidatorExcluding(0.0, 1.0)).build()).build());
             }

src/settings/modules/GlpkSettings.h

@@ -13,11 +13,9 @@ namespace storm {
             class GlpkSettings : public ModuleSettings {
             public:
                 /*!
-                 * Creates a new set of glpk settings that is managed by the given manager.
-                 *
-                 * @param settingsManager The responsible manager.
+                 * Creates a new set of glpk settings.
                  */
-                GlpkSettings(storm::settings::SettingsManager& settingsManager);
+                GlpkSettings();
                 
                 /*!
                  * Retrieves whether the output option was set.

src/settings/modules/GmmxxEquationSolverSettings.cpp

@@ -22,7 +22,7 @@ namespace storm {
             const std::string GmmxxEquationSolverSettings::precisionOptionName = "precision";
             const std::string GmmxxEquationSolverSettings::absoluteOptionName = "absolute";
 
-            GmmxxEquationSolverSettings::GmmxxEquationSolverSettings(storm::settings::SettingsManager& settingsManager) : ModuleSettings(settingsManager, moduleName) {
+            GmmxxEquationSolverSettings::GmmxxEquationSolverSettings() : ModuleSettings(moduleName) {
                 std::vector<std::string> methods = {"bicgstab", "qmr", "gmres", "jacobi"};
                 this->addOption(storm::settings::OptionBuilder(moduleName, techniqueOptionName, true, "The method to be used for solving linear equation systems with the gmm++ engine. Available are {bicgstab, qmr, gmres, jacobi}.").addArgument(storm::settings::ArgumentBuilder::createStringArgument("name", "The name of the method to use.").addValidationFunctionString(storm::settings::ArgumentValidators::stringInListValidator(methods)).setDefaultValueString("gmres").build()).build());
                 

src/settings/modules/GmmxxEquationSolverSettings.h

@@ -22,11 +22,9 @@ namespace storm {
                 enum class ConvergenceCriterion { Absolute, Relative };
                 
                 /*!
-                 * Creates a new set of gmm++ settings that is managed by the given manager.
-                 *
-                 * @param settingsManager The responsible manager.
+                 * Creates a new set of gmm++ settings.
                  */
-                GmmxxEquationSolverSettings(storm::settings::SettingsManager& settingsManager);
+                GmmxxEquationSolverSettings();
                 
                 /*!
                  * Retrieves whether the linear equation system method has been set.

src/settings/modules/GurobiSettings.cpp

@@ -16,7 +16,7 @@ namespace storm {
             const std::string GurobiSettings::threadsOption = "threads";
             const std::string GurobiSettings::outputOption = "output";
             
-            GurobiSettings::GurobiSettings(storm::settings::SettingsManager& settingsManager) : ModuleSettings(settingsManager, moduleName) {
+            GurobiSettings::GurobiSettings() : ModuleSettings(moduleName) {
                 this->addOption(storm::settings::OptionBuilder(moduleName, threadsOption, true, "The number of threads that may be used by Gurobi.").addArgument(storm::settings::ArgumentBuilder::createUnsignedIntegerArgument("count", "The number of threads.").setDefaultValueUnsignedInteger(1).build()).build());
                 
                 this->addOption(storm::settings::OptionBuilder(moduleName, outputOption, true, "If set, the Gurobi output will be printed to the command line.").build());

src/settings/modules/GurobiSettings.h

@@ -13,11 +13,9 @@ namespace storm {
             class GurobiSettings : public ModuleSettings {
             public:
                 /*!
-                 * Creates a new set of Gurobi settings that is managed by the given manager.
-                 *
-                 * @param settingsManager The responsible manager.
+                 * Creates a new set of Gurobi settings.
                  */
-                GurobiSettings(storm::settings::SettingsManager& settingsManager);
+                GurobiSettings();
                 
                 /*!
                  * Retrieves whether the integer tolerance has been set.

src/settings/modules/ModuleSettings.cpp

@@ -10,7 +10,7 @@ namespace storm {
     namespace settings {
         namespace modules {
             
-            ModuleSettings::ModuleSettings(storm::settings::SettingsManager& settingsManager, std::string const& moduleName) : settingsManager(settingsManager), moduleName(moduleName) {
+            ModuleSettings::ModuleSettings(std::string const& moduleName) : moduleName(moduleName) {
                 // Intentionally left empty.
             }
             
@@ -19,10 +19,6 @@ namespace storm {
             }
 
             void ModuleSettings::finalize() { }
-
-            storm::settings::SettingsManager const& ModuleSettings::getSettingsManager() const {
-                return this->settingsManager;
-            }
             
             void ModuleSettings::set(std::string const& name) {
                 return this->getOption(name).setHasOptionBeenSet();

src/settings/modules/ModuleSettings.h

@@ -27,10 +27,9 @@ namespace storm {
                 /*!
                  * Constructs a new settings object.
                  *
-                 * @param settingsManager The manager responsible for these settings.
                  * @param moduleName The name of the module for which to build the settings.
                  */
-                ModuleSettings(storm::settings::SettingsManager& settingsManager, std::string const& moduleName);
+                ModuleSettings(std::string const& moduleName);
                 
                 /*!
                  * Checks whether the settings are consistent. If they are inconsistent, an exception is thrown.
@@ -77,12 +76,6 @@ namespace storm {
                 uint_fast64_t getPrintLengthOfLongestOption() const;
                 
             protected:
-                /*!
-                 * Retrieves the manager responsible for the settings.
-                 *
-                 * @return The manager responsible for the settings.
-                 */
-                storm::settings::SettingsManager const& getSettingsManager() const;
                 
                 /*!
                  * Retrieves the option with the given long name. If no such option exists, an exception is thrown.
@@ -132,8 +125,6 @@ namespace storm {
                 void addOption(std::shared_ptr<Option> const& option);
                 
             private:
-                // The settings manager responsible for the settings.
-                storm::settings::SettingsManager const& settingsManager;
                 
                 // The name of the module.
                 std::string moduleName;

src/settings/modules/NativeEquationSolverSettings.cpp

@@ -20,7 +20,7 @@ namespace storm {
             const std::string NativeEquationSolverSettings::precisionOptionName = "precision";
             const std::string NativeEquationSolverSettings::absoluteOptionName = "absolute";
             
-            NativeEquationSolverSettings::NativeEquationSolverSettings(storm::settings::SettingsManager& settingsManager) : ModuleSettings(settingsManager, moduleName) {
+            NativeEquationSolverSettings::NativeEquationSolverSettings() : ModuleSettings(moduleName) {
                 std::vector<std::string> methods = { "jacobi", "gaussseidel", "sor" };
                 this->addOption(storm::settings::OptionBuilder(moduleName, techniqueOptionName, true, "The method to be used for solving linear equation systems with the native engine. Available are: { jacobi }.").addArgument(storm::settings::ArgumentBuilder::createStringArgument("name", "The name of the method to use.").addValidationFunctionString(storm::settings::ArgumentValidators::stringInListValidator(methods)).setDefaultValueString("jacobi").build()).build());
                 

src/settings/modules/NativeEquationSolverSettings.h

@@ -19,11 +19,9 @@ namespace storm {
                 enum class ConvergenceCriterion { Absolute, Relative };
                 
                 /*!
-                 * Creates a new set of native equation solver settings that is managed by the given manager.
-                 *
-                 * @param settingsManager The responsible manager.
+                 * Creates a new set of native equation solver settings.
                  */
-                NativeEquationSolverSettings(storm::settings::SettingsManager& settingsManager);
+                NativeEquationSolverSettings();
                 
                 /*!
                  * Retrieves whether the linear equation system technique has been set.

src/settings/modules/ParametricSettings.cpp

@@ -16,7 +16,7 @@ namespace storm {
             const std::string ParametricSettings::exportResultDestinationPathOptionName = "resultfile";
             const std::string ParametricSettings::derivativesOptionName = "derivatives";
             
-            ParametricSettings::ParametricSettings(storm::settings::SettingsManager& settingsManager) : ModuleSettings(settingsManager, moduleName) {
+            ParametricSettings::ParametricSettings() : ModuleSettings(moduleName) {
                 this->addOption(storm::settings::OptionBuilder(moduleName, encodeSmt2StrategyOptionName, true, "Set the smt2 encoding strategy.")
                                 .addArgument(storm::settings::ArgumentBuilder::createStringArgument("strategy", "the used strategy").build()).build());
                 this->addOption(storm::settings::OptionBuilder(moduleName, exportSmt2DestinationPathOptionName, true, "A path to a file where the result should be saved.")

src/settings/modules/ParametricSettings.h

@@ -23,11 +23,9 @@ namespace storm {
 				enum class Smt2EncodingStrategy {FULL_TRANSITION_SYSTEM, ONLY_SCC_ENTRY_STATES, HIGH_INDEGREE, RATIONAL_FUNCTION};
                 
                 /*!
-                 * Creates a new set of parametric model checking settings that is managed by the given manager.
-                 *
-                 * @param settingsManager The responsible manager.
+                 * Creates a new set of parametric model checking settings.
                  */
-                ParametricSettings(storm::settings::SettingsManager& settingsManager);
+                ParametricSettings();
 				
 				/**
 				 * Retrieves whether the model checking result should be exported to a file.

src/settings/modules/SparseDtmcEliminationModelCheckerSettings.cpp

@@ -16,7 +16,7 @@ namespace storm {
             const std::string SparseDtmcEliminationModelCheckerSettings::entryStatesLastOptionName = "entrylast";
             const std::string SparseDtmcEliminationModelCheckerSettings::maximalSccSizeOptionName = "sccsize";
             
-            SparseDtmcEliminationModelCheckerSettings::SparseDtmcEliminationModelCheckerSettings(storm::settings::SettingsManager& settingsManager) : ModuleSettings(settingsManager, moduleName) {
+            SparseDtmcEliminationModelCheckerSettings::SparseDtmcEliminationModelCheckerSettings() : ModuleSettings(moduleName) {
                 std::vector<std::string> orders = {"fw", "fwrev", "bw", "bwrev", "rand", "spen", "dpen", "regex"};
                 this->addOption(storm::settings::OptionBuilder(moduleName, eliminationOrderOptionName, true, "The order that is to be used for the elimination techniques. Available are {fw, fwrev, bw, bwrev, rand, spen, dpen}.").addArgument(storm::settings::ArgumentBuilder::createStringArgument("name", "The name of the order in which states are chosen for elimination.").addValidationFunctionString(storm::settings::ArgumentValidators::stringInListValidator(orders)).setDefaultValueString("fwrev").build()).build());
                 

src/settings/modules/SparseDtmcEliminationModelCheckerSettings.h

@@ -23,11 +23,9 @@ namespace storm {
                 enum class EliminationMethod { State, Scc, Hybrid};
                 
                 /*!
-                 * Creates a new set of parametric model checking settings that is managed by the given manager.
-                 *
-                 * @param settingsManager The responsible manager.
+                 * Creates a new set of parametric model checking settings.
                  */
-                SparseDtmcEliminationModelCheckerSettings(storm::settings::SettingsManager& settingsManager);
+                SparseDtmcEliminationModelCheckerSettings();
                 
                 /*!
                  * Retrieves the selected elimination method.

src/settings/modules/SylvanSettings.cpp

@@ -15,7 +15,7 @@ namespace storm {
             const std::string SylvanSettings::maximalMemoryOptionName = "maxmem";
             const std::string SylvanSettings::threadCountOptionName = "threads";
             
-            SylvanSettings::SylvanSettings(storm::settings::SettingsManager& settingsManager) : ModuleSettings(settingsManager, moduleName) {
+            SylvanSettings::SylvanSettings() : ModuleSettings(moduleName) {
                 this->addOption(storm::settings::OptionBuilder(moduleName, maximalMemoryOptionName, true, "Sets the upper bound of memory available to Sylvan in MB.").addArgument(storm::settings::ArgumentBuilder::createUnsignedIntegerArgument("value", "The memory available to Sylvan.").setDefaultValueUnsignedInteger(4096).build()).build());
                 this->addOption(storm::settings::OptionBuilder(moduleName, threadCountOptionName, true, "Sets the number of threads used by Sylvan.").addArgument(storm::settings::ArgumentBuilder::createUnsignedIntegerArgument("value", "The number of threads available to Sylvan (0 means 'auto-detect').").setDefaultValueUnsignedInteger(0).build()).build());
             }

src/settings/modules/SylvanSettings.h

@@ -13,11 +13,9 @@ namespace storm {
             class SylvanSettings : public ModuleSettings {
             public:
                 /*!
-                 * Creates a new set of CUDD settings that is managed by the given manager.
-                 *
-                 * @param settingsManager The responsible manager.
+                 * Creates a new set of CUDD settings.
                  */
-                SylvanSettings(storm::settings::SettingsManager& settingsManager);
+                SylvanSettings();
                 
                 /*!
                  * Retrieves the maximal amount of memory (in megabytes) that Sylvan can occupy.

src/settings/modules/TopologicalValueIterationEquationSolverSettings.cpp

@@ -19,7 +19,7 @@ namespace storm {
 			const std::string TopologicalValueIterationEquationSolverSettings::precisionOptionName = "precision";
 			const std::string TopologicalValueIterationEquationSolverSettings::absoluteOptionName = "absolute";
 
-			TopologicalValueIterationEquationSolverSettings::TopologicalValueIterationEquationSolverSettings(storm::settings::SettingsManager& settingsManager) : ModuleSettings(settingsManager, moduleName) {
+			TopologicalValueIterationEquationSolverSettings::TopologicalValueIterationEquationSolverSettings() : ModuleSettings(moduleName) {
                 
                 this->addOption(storm::settings::OptionBuilder(moduleName, maximalIterationsOptionName, false, "The maximal number of iterations to perform before iterative solving is aborted.").setShortName(maximalIterationsOptionShortName).addArgument(storm::settings::ArgumentBuilder::createUnsignedIntegerArgument("count", "The maximal iteration count.").setDefaultValueUnsignedInteger(20000).build()).build());
                 

src/settings/modules/TopologicalValueIterationEquationSolverSettings.h

@@ -17,11 +17,9 @@ namespace storm {
 				enum class ConvergenceCriterion { Absolute, Relative };
 
                 /*!
-                 * Creates a new set of topological value iteration settings that is managed by the given manager.
-                 *
-                 * @param settingsManager The responsible manager.
+                 * Creates a new set of topological value iteration settings.
                  */
-				TopologicalValueIterationEquationSolverSettings(storm::settings::SettingsManager& settingsManager);
+				TopologicalValueIterationEquationSolverSettings();
 
                 
                 /*!