From 50f891b9f239c7107fc243d476bed4e6b757508b Mon Sep 17 00:00:00 2001 From: dehnert Date: Sat, 12 Jan 2013 19:35:00 +0100 Subject: [PATCH] Removed some unnecessary boost stuff from IR expressions. Separated header and source file for all non-expression IR entities (expressions are still to come). Added comments for these classes. --- src/ir/Assignment.cpp | 46 +++++++ src/ir/Assignment.h | 70 ++++++----- src/ir/BooleanVariable.cpp | 41 +++++++ src/ir/BooleanVariable.h | 55 +++++---- src/ir/Command.cpp | 43 +++++++ src/ir/Command.h | 60 ++++----- src/ir/IR.h | 9 +- src/ir/IntegerVariable.cpp | 39 ++++++ src/ir/IntegerVariable.h | 61 +++++----- src/ir/Module.cpp | 46 +++++++ src/ir/Module.h | 70 ++++++----- src/ir/Program.cpp | 67 ++++++++++ src/ir/Program.h | 114 +++++++++--------- src/ir/RewardModel.cpp | 42 +++++++ src/ir/RewardModel.h | 67 +++++----- src/ir/StateReward.cpp | 35 ++++++ src/ir/StateReward.h | 51 +++++--- src/ir/TransitionReward.cpp | 35 ++++++ src/ir/TransitionReward.h | 53 +++++--- src/ir/Update.cpp | 45 +++++++ src/ir/Update.h | 61 +++++----- src/ir/Variable.cpp | 38 ++++++ src/ir/Variable.h | 68 ++++++----- .../BinaryBooleanFunctionExpression.h | 7 -- .../BinaryNumericalFunctionExpression.h | 7 -- src/ir/expressions/BinaryRelationExpression.h | 7 -- .../expressions/BooleanConstantExpression.h | 7 +- src/ir/expressions/BooleanLiteral.h | 5 - src/ir/expressions/ConstantExpression.h | 5 - src/ir/expressions/DoubleConstantExpression.h | 5 - src/ir/expressions/DoubleLiteral.h | 5 - .../expressions/IntegerConstantExpression.h | 5 - src/ir/expressions/IntegerLiteral.h | 5 - .../UnaryBooleanFunctionExpression.h | 6 - .../UnaryNumericalFunctionExpression.h | 6 - src/ir/expressions/VariableExpression.h | 5 - 36 files changed, 892 insertions(+), 399 deletions(-) create mode 100644 src/ir/Assignment.cpp create mode 100644 src/ir/BooleanVariable.cpp create mode 100644 src/ir/Command.cpp create mode 100644 src/ir/IntegerVariable.cpp create mode 100644 src/ir/Module.cpp create mode 100644 src/ir/Program.cpp create mode 100644 src/ir/RewardModel.cpp create mode 100644 src/ir/StateReward.cpp create mode 100644 src/ir/TransitionReward.cpp create mode 100644 src/ir/Update.cpp create mode 100644 src/ir/Variable.cpp diff --git a/src/ir/Assignment.cpp b/src/ir/Assignment.cpp new file mode 100644 index 000000000..095a922f3 --- /dev/null +++ b/src/ir/Assignment.cpp @@ -0,0 +1,46 @@ +/* + * Assignment.cpp + * + * Created on: 12.01.2013 + * Author: Christian Dehnert + */ + +#include "Assignment.h" + +#include + +namespace storm { + +namespace ir { + +// Initializes all members with their default constructors. +Assignment::Assignment() : variableName(), expression() { + // Nothing to do here. +} + +// Initializes all members according to the given values. +Assignment::Assignment(std::string variableName, std::shared_ptr expression) + : variableName(variableName), expression(expression) { + // Nothing to do here. +} + +// Returns the name of the variable associated with this assignment. +std::string const& Assignment::getVariableName() const { + return variableName; +} + +// Returns the expression associated with this assignment. +std::shared_ptr const& Assignment::getExpression() const { + return expression; +} + +// Build a string representation of the assignment. +std::string Assignment::toString() const { + std::stringstream result; + result << "(" << variableName << "' = " << expression->toString() << ")"; + return result.str(); +} + +} // namespace ir + +} // namespace storm diff --git a/src/ir/Assignment.h b/src/ir/Assignment.h index e6069d48f..019cc55eb 100644 --- a/src/ir/Assignment.h +++ b/src/ir/Assignment.h @@ -2,49 +2,65 @@ * Assignment.h * * Created on: 06.01.2013 - * Author: chris + * Author: Christian Dehnert */ -#ifndef ASSIGNMENT_H_ -#define ASSIGNMENT_H_ +#ifndef STORM_IR_ASSIGNMENT_H_ +#define STORM_IR_ASSIGNMENT_H_ #include "expressions/BaseExpression.h" +#include + namespace storm { namespace ir { +/*! + * A class representing the assignment of an expression to a variable. + */ class Assignment { public: - - Assignment() : variableName(""), expression(nullptr) { - - } - - Assignment(std::string variableName, std::shared_ptr expression) - : variableName(variableName), expression(expression) { - - } - - std::string getVariableName() { - return variableName; - } - - std::shared_ptr getExpression() { - return expression; - } - - std::string toString() { - return "(" + variableName + "' = " + expression->toString() + ")"; - } + /*! + * Default constructor. Creates an empty assignment. + */ + Assignment(); + + /*! + * Constructs an assignment using the given variable name and expression. + * @param variableName the variable that this assignment targets. + * @param expression the expression to assign to the variable. + */ + Assignment(std::string variableName, std::shared_ptr expression); + + /*! + * Retrieves the name of the variable that this assignment targets. + * @returns the name of the variable that this assignment targets. + */ + std::string const& getVariableName() const; + + /*! + * Retrieves the expression that is assigned to the variable. + * @returns the expression that is assigned to the variable. + */ + std::shared_ptr const& getExpression() const; + + /*! + * Retrieves a string representation of this assignment. + * @returns a string representation of this assignment. + */ + std::string toString() const; private: + // The name of the variable that this assignment targets. std::string variableName; + + // The expression that is assigned to the variable. std::shared_ptr expression; }; -} +} // namespace ir -} +} // namespace storm -#endif /* ASSIGNMENT_H_ */ +#endif /* STORM_IR_ASSIGNMENT_H_ */ diff --git a/src/ir/BooleanVariable.cpp b/src/ir/BooleanVariable.cpp new file mode 100644 index 000000000..e524d6753 --- /dev/null +++ b/src/ir/BooleanVariable.cpp @@ -0,0 +1,41 @@ +/* + * BooleanVariable.cpp + * + * Created on: 12.01.2013 + * Author: Christian Dehnert + */ + +#include "BooleanVariable.h" + +#include + +namespace storm { + +namespace ir { + +// Initializes all members with their default constructors. +BooleanVariable::BooleanVariable() : Variable() { + // Nothing to do here. +} + +// Initializes all members according to the given values. +BooleanVariable::BooleanVariable(std::string variableName, + std::shared_ptr initialValue) + : Variable(variableName, initialValue) { + // Nothing to do here. +} + +// Build a string representation of the variable. +std::string BooleanVariable::toString() const { + std::stringstream result; + result << getVariableName() << ": bool"; + if (this->getInitialValue() != nullptr) { + result << " init " << this->getInitialValue()->toString(); + } + result << ";"; + return result.str(); +} + +} // namespace ir + +} // namespace storm diff --git a/src/ir/BooleanVariable.h b/src/ir/BooleanVariable.h index eccf92078..dc832399e 100644 --- a/src/ir/BooleanVariable.h +++ b/src/ir/BooleanVariable.h @@ -2,42 +2,45 @@ * BooleanVariable.h * * Created on: 08.01.2013 - * Author: chris + * Author: Christian Dehnert */ -#ifndef BOOLEANVARIABLE_H_ -#define BOOLEANVARIABLE_H_ +#ifndef STORM_IR_BOOLEANVARIABLE_H_ +#define STORM_IR_BOOLEANVARIABLE_H_ + +#include "Variable.h" +#include namespace storm { namespace ir { +/*! + * A class representing a boolean variable. + */ class BooleanVariable : public Variable { public: - BooleanVariable() { - - } - - BooleanVariable(std::string variableName, std::shared_ptr initialValue = nullptr) : Variable(variableName, initialValue) { - - } - - virtual ~BooleanVariable() { - - } - - virtual std::string toString() { - std::string result = getVariableName() + ": bool"; - if (this->getInitialValue() != nullptr) { - result += " init " + this->getInitialValue()->toString(); - } - result += ";"; - return result; - } + /*! + * Default constructor. Creates a boolean variable without a name. + */ + BooleanVariable(); + + /*! + * Creates a boolean variable with the given name and the given initial value. + * @param variableName the name of the variable. + * @param initialValue the expression that defines the initial value of the variable. + */ + BooleanVariable(std::string variableName, std::shared_ptr initialValue = std::shared_ptr()); + + /*! + * Retrieves a string representation of this variable. + * @returns a string representation of this variable. + */ + std::string toString() const; }; -} +} // namespace ir -} +} // namespace storm -#endif /* BOOLEANVARIABLE_H_ */ +#endif /* STORM_IR_BOOLEANVARIABLE_H_ */ diff --git a/src/ir/Command.cpp b/src/ir/Command.cpp new file mode 100644 index 000000000..832fbb302 --- /dev/null +++ b/src/ir/Command.cpp @@ -0,0 +1,43 @@ +/* + * Command.cpp + * + * Created on: 12.01.2013 + * Author: Christian Dehnert + */ + +#include "Command.h" + +#include + +namespace storm { + +namespace ir { + +// Initializes all members with their default constructors. +Command::Command() : commandName(), guardExpression(), updates() { + // Nothing to do here. +} + +// Initializes all members according to the given values. +Command::Command(std::string commandName, std::shared_ptr guardExpression, std::vector updates) + : commandName(commandName), guardExpression(guardExpression), updates(updates) { + // Nothing to do here. +} + +// Build a string representation of the command. +std::string Command::toString() const { + std::stringstream result; + result << "[" << commandName << "] " << guardExpression->toString() << " -> "; + for (uint_fast64_t i = 0; i < updates.size(); ++i) { + result << updates[i].toString(); + if (i < updates.size() - 1) { + result << " + "; + } + } + result << ";"; + return result.str(); +} + +} // namespace ir + +} // namespace storm diff --git a/src/ir/Command.h b/src/ir/Command.h index fa881cb52..186d81058 100644 --- a/src/ir/Command.h +++ b/src/ir/Command.h @@ -2,54 +2,58 @@ * Command.h * * Created on: 06.01.2013 - * Author: chris + * Author: Christian Dehnert */ -#ifndef COMMAND_H_ -#define COMMAND_H_ +#ifndef STORM_IR_COMMAND_H_ +#define STORM_IR_COMMAND_H_ #include "expressions/BaseExpression.h" #include "Update.h" #include +#include namespace storm { namespace ir { +/*! + * A class representing a command. + */ class Command { public: - - Command() : commandName(""), guardExpression(nullptr), updates() { - - } - - Command(std::string commandName, std::shared_ptr guardExpression, std::vector updates) - : commandName(commandName), guardExpression(guardExpression), updates(updates) { - - } - - std::string toString() { - std::string result = "[" + commandName + "] " + guardExpression->toString() + " -> "; - for (uint_fast64_t i = 0; i < updates.size(); ++i) { - result += updates[i].toString(); - if (i < updates.size() - 1) { - result += " + "; - } - } - result += ";"; - return result; - } + /*! + * Default constructor. Creates a a command without name, guard and updates. + */ + Command(); + + /*! + * Creates a command with the given name, guard and updates. + * @param commandName the name of the command. + * @param guardExpression the expression that defines the guard of the command. + */ + Command(std::string commandName, std::shared_ptr guardExpression, std::vector updates); + + /*! + * Retrieves a string representation of this command. + * @returns a string representation of this command. + */ + std::string toString() const; private: + // The name of the command. std::string commandName; + + // The expression that defines the guard of the command. std::shared_ptr guardExpression; - std::vector updates; + // The list of updates of the command. + std::vector updates; }; -} +} // namespace ir -} +} // namespace storm -#endif /* COMMAND_H_ */ +#endif /* STORM_IR_COMMAND_H_ */ diff --git a/src/ir/IR.h b/src/ir/IR.h index 029e88fed..80a794002 100644 --- a/src/ir/IR.h +++ b/src/ir/IR.h @@ -2,12 +2,13 @@ * IR.h * * Created on: 06.01.2013 - * Author: chris + * Author: Christian Dehnert */ -#ifndef IR_H_ -#define IR_H_ +#ifndef STORM_IR_IR_H_ +#define STORM_IR_IR_H_ +// Bundle all headers to make it easy to include them. #include "expressions/Expressions.h" #include "Assignment.h" #include "Update.h" @@ -21,4 +22,4 @@ #include "RewardModel.h" #include "Program.h" -#endif /* IR_H_ */ +#endif /* STORM_IR_IR_H_ */ diff --git a/src/ir/IntegerVariable.cpp b/src/ir/IntegerVariable.cpp new file mode 100644 index 000000000..6b6724b1a --- /dev/null +++ b/src/ir/IntegerVariable.cpp @@ -0,0 +1,39 @@ +/* + * IntegerVariable.cpp + * + * Created on: 12.01.2013 + * Author: Christian Dehnert + */ + +#include "IntegerVariable.h" + +#include + +namespace storm { + +namespace ir { + +// Initializes all members with their default constructors. +IntegerVariable::IntegerVariable() : lowerBound(), upperBound() { + // Nothing to do here. +} + +// Initializes all members according to the given values. +IntegerVariable::IntegerVariable(std::string variableName, std::shared_ptr lowerBound, std::shared_ptr upperBound, std::shared_ptr initialValue) : Variable(variableName, initialValue), lowerBound(lowerBound), upperBound(upperBound) { + // Nothing to do here. +} + +// Build a string representation of the variable. +std::string IntegerVariable::toString() const { + std::stringstream result; + result << this->getVariableName() << ": [" << lowerBound->toString() << ".." << upperBound->toString() << "]"; + if (this->getInitialValue() != nullptr) { + result << " init " + this->getInitialValue()->toString(); + } + result << ";"; + return result.str(); +} + +} // namespace ir + +} // namespace storm diff --git a/src/ir/IntegerVariable.h b/src/ir/IntegerVariable.h index 78c638954..d687e2a04 100644 --- a/src/ir/IntegerVariable.h +++ b/src/ir/IntegerVariable.h @@ -2,49 +2,56 @@ * IntegerVariable.h * * Created on: 08.01.2013 - * Author: chris + * Author: Christian Dehnert */ -#ifndef INTEGERVARIABLE_H_ -#define INTEGERVARIABLE_H_ +#ifndef STORM_IR_INTEGERVARIABLE_H_ +#define STORM_IR_INTEGERVARIABLE_H_ -#include "Variable.h" #include "expressions/BaseExpression.h" +#include "Variable.h" +#include namespace storm { namespace ir { +/*! + * A class representing an integer variable. + */ class IntegerVariable : public Variable { public: - IntegerVariable() : lowerBound(nullptr), upperBound(nullptr) { - - } - - IntegerVariable(std::string variableName, std::shared_ptr lowerBound, std::shared_ptr upperBound, std::shared_ptr initialValue = nullptr) : Variable(variableName, initialValue), lowerBound(lowerBound), upperBound(upperBound) { - - } - - virtual ~IntegerVariable() { - - } - - virtual std::string toString() { - std::string result = getVariableName() + ": [" + lowerBound->toString() + ".." + upperBound->toString() + "]"; - if (this->getInitialValue() != nullptr) { - result += " init " + this->getInitialValue()->toString(); - } - result += ";"; - return result; - } + /*! + * Default constructor. Creates an integer variable without a name and lower and upper bounds. + */ + IntegerVariable(); + + /*! + * Creates an integer variable with the given name, lower and upper bounds and the given initial + * value. + * @param variableName the name of the variable. + * @param lowerBound the lower bound of the domain of the variable. + * @param upperBound the upper bound of the domain of the variable. + * @param initialValue the expression that defines the initial value of the variable. + */ + IntegerVariable(std::string variableName, std::shared_ptr lowerBound, std::shared_ptr upperBound, std::shared_ptr initialValue = std::shared_ptr()); + + /*! + * Retrieves a string representation of this variable. + * @returns a string representation of this variable. + */ + std::string toString() const; private: + // The lower bound of the domain of the variable. std::shared_ptr lowerBound; + + // The upper bound of the domain of the variable. std::shared_ptr upperBound; }; -} +} // namespace ir -} +} // namespace storm -#endif /* INTEGERVARIABLE_H_ */ +#endif /* STORM_IR_INTEGERVARIABLE_H_ */ diff --git a/src/ir/Module.cpp b/src/ir/Module.cpp new file mode 100644 index 000000000..5f28a8d13 --- /dev/null +++ b/src/ir/Module.cpp @@ -0,0 +1,46 @@ +/* + * Module.cpp + * + * Created on: 12.01.2013 + * Author: Christian Dehnert + */ + +#include "Module.h" + +#include + +namespace storm { + +namespace ir { + +// Initializes all members with their default constructors. +Module::Module() : moduleName(), booleanVariables(), integerVariables(), commands() { + // Nothing to do here. +} + +// Initializes all members according to the given values. +Module::Module(std::string moduleName, std::map booleanVariables, std::map integerVariables, std::vector commands) + : moduleName(moduleName), booleanVariables(booleanVariables), integerVariables(integerVariables), commands(commands) { + // Nothing to do here. +} + +// Build a string representation of the variable. +std::string Module::toString() const { + std::stringstream result; + result << "module " << moduleName << std::endl; + for (auto variable : booleanVariables) { + result << "\t" << variable.second.toString() << std::endl; + } + for (auto variable : integerVariables) { + result << "\t" << variable.second.toString() << std::endl; + } + for (auto command : commands) { + result << "\t" << command.toString() << std::endl; + } + result << "endmodule" << std::endl; + return result.str(); +} + +} // namespace ir + +} // namespace storm diff --git a/src/ir/Module.h b/src/ir/Module.h index 4b673a757..ad0218730 100644 --- a/src/ir/Module.h +++ b/src/ir/Module.h @@ -2,61 +2,65 @@ * Module.h * * Created on: 04.01.2013 - * Author: chris + * Author: Christian Dehnert */ -#ifndef MODULE_H_ -#define MODULE_H_ +#ifndef STORM_IR_MODULE_H_ +#define STORM_IR_MODULE_H_ #include "BooleanVariable.h" #include "IntegerVariable.h" #include "Command.h" #include +#include +#include namespace storm { namespace ir { +/*! + * A class representing a module. + */ class Module { public: - Module() : moduleName(""), booleanVariables(), integerVariables(), commands() { - - } - - Module(std::string moduleName, std::map booleanVariables, std::map integerVariables, std::vector commands) - : moduleName(moduleName), booleanVariables(booleanVariables), integerVariables(integerVariables), commands(commands) { - - } - - Module(std::string moduleName, std::vector commands) : moduleName(moduleName), booleanVariables(), integerVariables(), commands(commands) { - - } - - std::string toString() { - std::string result = "module " + moduleName + "\n"; - for (auto variable : booleanVariables) { - result += "\t" + variable.second.toString() + "\n"; - } - for (auto variable : integerVariables) { - result += "\t" + variable.second.toString() + "\n"; - } - for (auto command : commands) { - result += "\t" + command.toString() + "\n"; - } - result += "endmodule\n"; - return result; - } + /*! + * Default constructor. Creates an empty module. + */ + Module(); + + /*! + * Creates a module with the given name, variables and commands. + * @param moduleName the name of the module. + * @param booleanVariables a map of boolean variables. + * @param integerVariables a map of integer variables. + * @param commands the vector of commands. + */ + Module(std::string moduleName, std::map booleanVariables, std::map integerVariables, std::vector commands); + + /*! + * Retrieves a string representation of this variable. + * @returns a string representation of this variable. + */ + std::string toString() const; private: + // The name of the module. std::string moduleName; + + // A map of boolean variable names to their details. std::map booleanVariables; + + // A map of integer variable names to their details. std::map integerVariables; + + // The commands associated with the module. std::vector commands; }; -} +} // namespace ir -} +} // namespace storm -#endif /* MODULE_H_ */ +#endif /* STORM_IR_MODULE_H_ */ diff --git a/src/ir/Program.cpp b/src/ir/Program.cpp new file mode 100644 index 000000000..5a250405e --- /dev/null +++ b/src/ir/Program.cpp @@ -0,0 +1,67 @@ +/* + * Program.cpp + * + * Created on: 12.01.2013 + * Author: Christian Dehnert + */ + +#include "Program.h" + +#include + +namespace storm { + +namespace ir { + +// Initializes all members with their default constructors. +Program::Program() : modelType(UNDEFINED), booleanUndefinedConstantExpressions(), integerUndefinedConstantExpressions(), doubleUndefinedConstantExpressions(), modules(), rewards() { + // Nothing to do here. +} + +// Initializes all members according to the given values. +Program::Program(ModelType modelType, std::map> booleanUndefinedConstantExpressions, std::map> integerUndefinedConstantExpressions, std::map> doubleUndefinedConstantExpressions, std::vector modules, std::map rewards, std::map> labels) + : modelType(modelType), booleanUndefinedConstantExpressions(booleanUndefinedConstantExpressions), integerUndefinedConstantExpressions(integerUndefinedConstantExpressions), doubleUndefinedConstantExpressions(doubleUndefinedConstantExpressions), modules(modules), rewards(rewards), labels(labels) { + // Nothing to do here. +} + +// Build a string representation of the program. +std::string Program::toString() const { + std::stringstream result; + switch (modelType) { + case UNDEFINED: result << "undefined"; break; + case DTMC: result << "dtmc"; break; + case CTMC: result << "ctmc"; break; + case MDP: result << "mdp"; break; + case CTMDP: result << "ctmdp"; break; + } + result << std::endl; + + for (auto element : booleanUndefinedConstantExpressions) { + result << "const bool " << element.first << ";" << std::endl; + } + for (auto element : integerUndefinedConstantExpressions) { + result << "const int " << element.first << ";" << std::endl; + } + for (auto element : doubleUndefinedConstantExpressions) { + result << "const double " << element.first << ";" << std::endl; + } + result << std::endl; + + for (auto mod : modules) { + result << mod.toString() << std::endl; + } + + for (auto rewardModel : rewards) { + result << rewardModel.second.toString() << std::endl; + } + + for (auto label : labels) { + result << "label " << label.first << " = " << label.second->toString() <<";" << std::endl; + } + + return result.str(); +} + +} // namespace ir + +} // namepsace storm diff --git a/src/ir/Program.h b/src/ir/Program.h index 57a6ac11a..8fcd7c10f 100644 --- a/src/ir/Program.h +++ b/src/ir/Program.h @@ -2,11 +2,11 @@ * Program.h * * Created on: 04.01.2013 - * Author: chris + * Author: Christian Dehnert */ -#ifndef PROGRAM_H_ -#define PROGRAM_H_ +#ifndef STORM_IR_PROGRAM_H_ +#define STORM_IR_PROGRAM_H_ #include "expressions/BaseExpression.h" #include "expressions/BooleanConstantExpression.h" @@ -15,82 +15,76 @@ #include "Module.h" #include "RewardModel.h" +#include +#include +#include + namespace storm { namespace ir { +/*! + * A class representing a program. + */ class Program { public: + /*! + * An enum for the different model types. + */ enum ModelType {UNDEFINED, DTMC, CTMC, MDP, CTMDP}; - Program() : modelType(UNDEFINED), booleanUndefinedConstantExpressions(), integerUndefinedConstantExpressions(), doubleUndefinedConstantExpressions(), modules(), rewards() { - - } - - Program(ModelType modelType, std::map> booleanUndefinedConstantExpressions, std::map> integerUndefinedConstantExpressions, std::map> doubleUndefinedConstantExpressions, std::vector modules, std::map rewards, std::map> labels) - : modelType(modelType), booleanUndefinedConstantExpressions(booleanUndefinedConstantExpressions), integerUndefinedConstantExpressions(integerUndefinedConstantExpressions), doubleUndefinedConstantExpressions(doubleUndefinedConstantExpressions), modules(modules), rewards(rewards), labels(labels) { - - } - - Program(ModelType modelType, std::map> booleanUndefinedConstantExpressions, std::map> integerUndefinedConstantExpressions, std::map> doubleUndefinedConstantExpressions, std::vector modules) - : modelType(modelType), booleanUndefinedConstantExpressions(booleanUndefinedConstantExpressions), integerUndefinedConstantExpressions(integerUndefinedConstantExpressions), doubleUndefinedConstantExpressions(doubleUndefinedConstantExpressions), modules(modules), rewards() { - - } - - - Program(ModelType modelType, std::vector modules) : modelType(modelType), booleanUndefinedConstantExpressions(), integerUndefinedConstantExpressions(), doubleUndefinedConstantExpressions(), modules(modules), rewards() { - - } - - std::string toString() { - std::string result = ""; - switch (modelType) { - case UNDEFINED: result += "undefined\n\n"; break; - case DTMC: result += "dtmc\n\n"; break; - case CTMC: result += "ctmc\n\n"; break; - case MDP: result += "mdp\n\n"; break; - case CTMDP: result += "ctmdp\n\n"; break; - } - for (auto element : booleanUndefinedConstantExpressions) { - result += "const bool " + element.first + ";\n"; - } - for (auto element : integerUndefinedConstantExpressions) { - result += "const int " + element.first + ";\n"; - } - for (auto element : doubleUndefinedConstantExpressions) { - result += "const double " + element.first + ";\n"; - } - result += "\n"; - for (auto mod : modules) { - result += mod.toString(); - result += "\n"; - } - - for (auto rewardModel : rewards) { - result += rewardModel.second.toString(); - result +="\n"; - } - - for (auto label : labels) { - result += "label " + label.first + " = " + label.second->toString() + ";\n"; - } - - return result; - } + /*! + * Default constructor. Creates an empty program. + */ + Program(); + + /*! + * Creates a program with the given model type, undefined constants, modules, rewards and labels. + * @param modelType the type of the model that this program gives rise to. + * @param booleanUndefinedConstantExpressions a map of undefined boolean constants to their + * expression nodes. + * @param integerUndefinedConstantExpressions a map of undefined integer constants to their + * expression nodes. + * @param doubleUndefinedConstantExpressions a map of undefined double constants to their + * expression nodes. + * @param modules The modules of the program. + * @param rewards The reward models of the program. + * @param labels The labels defined for this model. + */ + Program(ModelType modelType, std::map> booleanUndefinedConstantExpressions, std::map> integerUndefinedConstantExpressions, std::map> doubleUndefinedConstantExpressions, std::vector modules, std::map rewards, std::map> labels); + + /*! + * Retrieves a string representation of this program. + * @returns a string representation of this program. + */ + std::string toString() const; private: + // The type of the model. ModelType modelType; + + // A map of undefined boolean constants to their expression nodes. std::map> booleanUndefinedConstantExpressions; + + // A map of undefined integer constants to their expressions nodes. std::map> integerUndefinedConstantExpressions; + + // A mpa of undefined double constants to their expressions nodes. std::map> doubleUndefinedConstantExpressions; + + // The modules associated with the program. std::vector modules; + + // The reward models associated with the program. std::map rewards; + + // The labels that are defined for this model. std::map> labels; }; -} +} // namespace ir -} +} // namespace storm -#endif /* PROGRAM_H_ */ +#endif /* STORM_IR_PROGRAM_H_ */ diff --git a/src/ir/RewardModel.cpp b/src/ir/RewardModel.cpp new file mode 100644 index 000000000..d8549db6e --- /dev/null +++ b/src/ir/RewardModel.cpp @@ -0,0 +1,42 @@ +/* + * RewardModel.cpp + * + * Created on: 12.01.2013 + * Author: Christian Dehnert + */ + +#include "RewardModel.h" + +#include + +namespace storm { + +namespace ir { + +// Initializes all members with their default constructors. +RewardModel::RewardModel() : rewardModelName(), stateRewards(), transitionRewards() { + // Nothing to do here. +} + +// Initializes all members according to the given values. +RewardModel::RewardModel(std::string rewardModelName, std::vector stateRewards, std::vector transitionRewards) : rewardModelName(rewardModelName), stateRewards(stateRewards), transitionRewards(transitionRewards) { + // Nothing to do here. +} + +// Build a string representation of the reward model. +std::string RewardModel::toString() const { + std::stringstream result; + result << "rewards \"" << rewardModelName << "\"" << std::endl; + for (auto reward : stateRewards) { + result << reward.toString() << std::endl; + } + for (auto reward : transitionRewards) { + result << reward.toString() << std::endl; + } + result << "endrewards" << std::endl; + return result.str(); +} + +} // namespace ir + +} // namespace storm diff --git a/src/ir/RewardModel.h b/src/ir/RewardModel.h index 21c08fa75..fcf8dcf01 100644 --- a/src/ir/RewardModel.h +++ b/src/ir/RewardModel.h @@ -2,52 +2,59 @@ * RewardModel.h * * Created on: 04.01.2013 - * Author: chris + * Author: Christian Dehnert */ -#ifndef REWARDMODEL_H_ -#define REWARDMODEL_H_ +#ifndef STORM_IR_REWARDMODEL_H_ +#define STORM_IR_REWARDMODEL_H_ -#include +#include "StateReward.h" +#include "TransitionReward.h" + +#include +#include namespace storm { namespace ir { +/*! + * A class representing a reward model. + */ class RewardModel { public: - RewardModel() : rewardModelName(""), stateRewards(), transitionRewards() { - - } - - RewardModel(std::string rewardModelName, std::vector stateRewards, std::vector transitionRewards) : rewardModelName(rewardModelName), stateRewards(stateRewards), transitionRewards(transitionRewards) { - - } - - RewardModel(RewardModel const& other) : rewardModelName(other.rewardModelName), stateRewards(other.stateRewards), transitionRewards(other.transitionRewards) { - - } - - std::string toString() { - std::string result = "rewards \"" + rewardModelName + "\"\n"; - for (auto reward : stateRewards) { - result += reward.toString() + "\n"; - } - for (auto reward : transitionRewards) { - result += reward.toString() + "\n"; - } - result += "endrewards\n"; - return result; - } + /*! + * Default constructor. Creates an empty reward model. + */ + RewardModel(); + + /*! + * Creates a reward module with the given name, state and transition rewards. + * @param rewardModelName the name of the reward model. + * @param stateRewards A vector of state-based reward. + * @param transitionRewards A vector of transition-based reward. + */ + RewardModel(std::string rewardModelName, std::vector stateRewards, std::vector transitionRewards); + + /*! + * Retrieves a string representation of this variable. + * @returns a string representation of this variable. + */ + std::string toString() const; private: + // The name of the reward model. std::string rewardModelName; + + // The state-based rewards associated with this reward model. std::vector stateRewards; + + // The transition-based rewards associated with this reward model. std::vector transitionRewards; }; -} +} // namespace ir -} +} // namespace storm -#endif /* REWARDMODEL_H_ */ +#endif /* STORM_IR_REWARDMODEL_H_ */ diff --git a/src/ir/StateReward.cpp b/src/ir/StateReward.cpp new file mode 100644 index 000000000..28ed4b72f --- /dev/null +++ b/src/ir/StateReward.cpp @@ -0,0 +1,35 @@ +/* + * StateReward.cpp + * + * Created on: 12.01.2013 + * Author: Christian Dehnert + */ + +#include "StateReward.h" + +#include + +namespace storm { + +namespace ir { + +// Initializes all members with their default constructors. +StateReward::StateReward() : statePredicate(), rewardValue() { + // Nothing to do here. +} + +// Initializes all members according to the given values. +StateReward::StateReward(std::shared_ptr statePredicate, std::shared_ptr rewardValue) : statePredicate(statePredicate), rewardValue(rewardValue) { + // Nothing to do here. +} + +// Build a string representation of the state reward. +std::string StateReward::toString() const { + std::stringstream result; + result << "\t" << statePredicate->toString() << ": " << rewardValue->toString() << ";"; + return result.str(); +} + +} // namespace ir + +} // namespace storm diff --git a/src/ir/StateReward.h b/src/ir/StateReward.h index 9128c74ff..0a127fd0c 100644 --- a/src/ir/StateReward.h +++ b/src/ir/StateReward.h @@ -2,39 +2,56 @@ * StateReward.h * * Created on: Jan 10, 2013 - * Author: chris + * Author: Christian Dehnert */ -#ifndef STATEREWARD_H_ -#define STATEREWARD_H_ +#ifndef STORM_IR_STATEREWARD_H_ +#define STORM_IR_STATEREWARD_H_ #include "expressions/BaseExpression.h" +#include + namespace storm { namespace ir { +/*! + * A class representing a state reward. + */ class StateReward { public: - StateReward() : statePredicate(nullptr), rewardValue(nullptr) { - - } - - StateReward(std::shared_ptr statePredicate, std::shared_ptr rewardValue) : statePredicate(statePredicate), rewardValue(rewardValue) { - - } - - std::string toString() { - return "\t" + statePredicate->toString() + ": " + rewardValue->toString() + ";"; - } + /*! + * Default constructor. Creates an empty state reward. + */ + StateReward(); + + /*! + * Creates a state reward for the states satisfying the given expression with the value given + * by a second expression. + * @param statePredicate the predicate that states earning this state-based reward need to + * satisfy. + * @param rewardValue an expression specifying the values of the rewards to attach to the + * states. + */ + StateReward(std::shared_ptr statePredicate, std::shared_ptr rewardValue); + + /*! + * Retrieves a string representation of this state reward. + * @returns a string representation of this state reward. + */ + std::string toString() const; private: + // The predicate that characterizes the states that obtain this reward. std::shared_ptr statePredicate; + + // The expression that specifies the value of the reward obtained. std::shared_ptr rewardValue; }; -} +} // namespace ir -} +} // namespace storm -#endif /* STATEREWARD_H_ */ +#endif /* STORM_IR_STATEREWARD_H_ */ diff --git a/src/ir/TransitionReward.cpp b/src/ir/TransitionReward.cpp new file mode 100644 index 000000000..6052f8b37 --- /dev/null +++ b/src/ir/TransitionReward.cpp @@ -0,0 +1,35 @@ +/* + * TransitionReward.cpp + * + * Created on: 12.01.2013 + * Author: Christian Dehnert + */ + +#include "TransitionReward.h" + +#include + +namespace storm { + +namespace ir { + +// Initializes all members with their default constructors. +TransitionReward::TransitionReward() : commandName(), statePredicate(), rewardValue() { + // Nothing to do here. +} + +// Initializes all members according to the given values. +TransitionReward::TransitionReward(std::string commandName, std::shared_ptr statePredicate, std::shared_ptr rewardValue) : commandName(commandName), statePredicate(statePredicate), rewardValue(rewardValue) { + // Nothing to do here. +} + +// Build a string representation of the transition reward. +std::string TransitionReward::toString() const { + std::stringstream result; + result << "\t[" << commandName << "] " << statePredicate->toString() << ": " << rewardValue->toString() << ";"; + return result.str(); +} + +} // namespace ir + +} // namespace storm diff --git a/src/ir/TransitionReward.h b/src/ir/TransitionReward.h index d444560ec..eaffe10ae 100644 --- a/src/ir/TransitionReward.h +++ b/src/ir/TransitionReward.h @@ -2,11 +2,11 @@ * TransitionReward.h * * Created on: Jan 10, 2013 - * Author: chris + * Author: Christian Dehnert */ -#ifndef TRANSITIONREWARD_H_ -#define TRANSITIONREWARD_H_ +#ifndef STORM_IR_TRANSITIONREWARD_H_ +#define STORM_IR_TRANSITIONREWARD_H_ #include "expressions/BaseExpression.h" @@ -14,28 +14,47 @@ namespace storm { namespace ir { +/*! + * A class representing a transition reward. + */ class TransitionReward { public: - TransitionReward() : commandName(""), statePredicate(nullptr), rewardValue(nullptr) { - - } - - TransitionReward(std::string commandName, std::shared_ptr statePredicate, std::shared_ptr rewardValue) : commandName(commandName), statePredicate(statePredicate), rewardValue(rewardValue) { - - } - - std::string toString() { - return "\t[" + commandName + "] " + statePredicate->toString() + ": " + rewardValue->toString() + ";"; - } + /*! + * Default constructor. Creates an empty transition reward. + */ + TransitionReward(); + + /*! + * Creates a transition reward for the transitions with the given name emanating from states + * satisfying the given expression with the value given by another expression. + * @param commandName the name of the command that obtains this reward. + * @param statePredicate the predicate that needs to hold before taking a transition with the + * previously specified name in order to obtain the reward. + * @param rewardValue an expression specifying the values of the rewards to attach to the + * transitions. + */ + TransitionReward(std::string commandName, std::shared_ptr statePredicate, std::shared_ptr rewardValue); + + /*! + * Retrieves a string representation of this transition reward. + * @returns a string representation of this transition reward. + */ + std::string toString() const; private: + // The name of the command this transition-based reward is attached to. std::string commandName; + + // A predicate that needs to be satisfied by states for the reward to be obtained (by taking + // a corresponding command transition). std::shared_ptr statePredicate; + + // The expression specifying the value of the reward obtained along the transitions. std::shared_ptr rewardValue; }; -} +} // namespace ir -} +} // namespace storm -#endif /* TRANSITIONREWARD_H_ */ +#endif /* STORM_IR_TRANSITIONREWARD_H_ */ diff --git a/src/ir/Update.cpp b/src/ir/Update.cpp new file mode 100644 index 000000000..4e59d46be --- /dev/null +++ b/src/ir/Update.cpp @@ -0,0 +1,45 @@ +/* + * Update.cpp + * + * Created on: 12.01.2013 + * Author: Christian Dehnert + */ + +#include "Update.h" + +#include + +namespace storm { + +namespace ir { + +// Initializes all members with their default constructors. +Update::Update() : likelihoodExpression(), assignments() { + // Nothing to do here. +} + +// Initializes all members according to the given values. +Update::Update(std::shared_ptr likelihoodExpression, std::map assignments) + : likelihoodExpression(likelihoodExpression), assignments(assignments) { + // Nothing to do here. +} + +// Build a string representation of the update. +std::string Update::toString() const { + std::stringstream result; + result << likelihoodExpression->toString() << " : "; + uint_fast64_t i = 0; + for (auto assignment : assignments) { + result << assignment.second.toString(); + ++i; + if (i < assignments.size() - 1) { + result << " & "; + } + + } + return result.str(); +} + +} // namespace ir + +} // namespace storm diff --git a/src/ir/Update.h b/src/ir/Update.h index 6f2d3535f..1aeb1d125 100644 --- a/src/ir/Update.h +++ b/src/ir/Update.h @@ -2,51 +2,56 @@ * Update.h * * Created on: 06.01.2013 - * Author: chris + * Author: Christian Dehnert */ -#ifndef UPDATE_H_ -#define UPDATE_H_ +#ifndef STORM_IR_UPDATE_H_ +#define STORM_IR_UPDATE_H_ #include "expressions/BaseExpression.h" +#include "Assignment.h" + #include +#include namespace storm { namespace ir { +/*! + * A class representing an update of a command. + */ class Update { public: - Update() : likelihoodExpression(nullptr), assignments() { - - } - - Update(std::shared_ptr likelihoodExpression, std::map assignments) - : likelihoodExpression(likelihoodExpression), assignments(assignments) { - - } - - std::string toString() { - std::string result = likelihoodExpression->toString() + " : "; - uint_fast64_t i = 0; - for (auto assignment : assignments) { - result += assignment.second.toString(); - ++i; - if (i < assignments.size() - 1) { - result += " & "; - } - - } - return result; - } + /*! + * Default constructor. Creates an empty update. + */ + Update(); + + /*! + * Creates an update with the given expression specifying the likelihood and the mapping of + * variable to their assignments. + * @param likelihoodExpression an expression specifying the likelihood of this update. + * @param assignments a map of variable names to their assignments. + */ + Update(std::shared_ptr likelihoodExpression, std::map assignments); + + /*! + * Retrieves a string representation of this update. + * @returns a string representation of this update. + */ + std::string toString() const; private: + // An expression specifying the likelihood of taking this update. std::shared_ptr likelihoodExpression; + + // A mapping of variable names to their assignments in this update. std::map assignments; }; -} +} // namespace ir -} +} // namespace storm -#endif /* UPDATE_H_ */ +#endif /*STORM_IR_UPDATE_H_ */ diff --git a/src/ir/Variable.cpp b/src/ir/Variable.cpp new file mode 100644 index 000000000..a735fa94d --- /dev/null +++ b/src/ir/Variable.cpp @@ -0,0 +1,38 @@ +/* + * Variable.cpp + * + * Created on: 12.01.2013 + * Author: Christian Dehnert + */ + +#include "Variable.h" + +#include + +namespace storm { + +namespace ir { + +// Initializes all members with their default constructors. +Variable::Variable() : variableName(), initialValue() { + // Nothing to do here. +} + +// Initializes all members according to the given values. +Variable::Variable(std::string variableName, std::shared_ptr initialValue) : variableName(variableName), initialValue(initialValue) { + // Nothing to do here. +} + +// Return the name of the variable. +std::string const& Variable::getVariableName() const { + return variableName; +} + +// Return the expression for the initial value of the variable. +std::shared_ptr const& Variable::getInitialValue() const { + return initialValue; +} + +} // namespace ir + +} // namespace storm diff --git a/src/ir/Variable.h b/src/ir/Variable.h index c015bb98b..bbd567073 100644 --- a/src/ir/Variable.h +++ b/src/ir/Variable.h @@ -2,50 +2,60 @@ * Variable.h * * Created on: 06.01.2013 - * Author: chris + * Author: Christian Dehnert */ -#ifndef VARIABLE_H_ -#define VARIABLE_H_ +#ifndef STORM_IR_VARIABLE_H_ +#define STORM_IR_VARIABLE_H_ + +#include "expressions/BaseExpression.h" + +#include namespace storm { namespace ir { +/*! + * A class representing a untyped variable. + */ class Variable { public: - Variable() : variableName(""), initialValue(nullptr) { - - } - - Variable(std::string variableName, std::shared_ptr initialValue = nullptr) : variableName(variableName), initialValue(initialValue) { - - } - - virtual ~Variable() { - - } - - virtual std::string toString() { - return variableName; - } - - std::string getVariableName() { - return variableName; - } - - std::shared_ptr getInitialValue() { - return initialValue; - } + /*! + * Default constructor. Creates an unnamed, untyped variable without initial value. + */ + Variable(); + + /*! + * Creates an untyped variable with the given name and initial value. + * @param variableName the name of the variable. + * @param initialValue the expression that defines the initial value of the variable. + */ + Variable(std::string variableName, std::shared_ptr initialValue = std::shared_ptr()); + + /*! + * Retrieves the name of the variable. + * @returns the name of the variable. + */ + std::string const& getVariableName() const; + + /*! + * Retrieves the expression defining the initial value of the variable. + * @returns the expression defining the initial value of the variable. + */ + std::shared_ptr const& getInitialValue() const; private: + // The name of the variable. std::string variableName; + + // The expression defining the initial value of the variable. std::shared_ptr initialValue; }; -} +} // namespace ir -} +} // namespace storm -#endif /* VARIABLE_H_ */ +#endif /* STORM_IR_VARIABLE_H_ */ diff --git a/src/ir/expressions/BinaryBooleanFunctionExpression.h b/src/ir/expressions/BinaryBooleanFunctionExpression.h index 5a745ba36..bd388dc04 100644 --- a/src/ir/expressions/BinaryBooleanFunctionExpression.h +++ b/src/ir/expressions/BinaryBooleanFunctionExpression.h @@ -53,11 +53,4 @@ public: } -BOOST_FUSION_ADAPT_STRUCT( - storm::ir::expressions::BinaryBooleanFunctionExpression, - (std::shared_ptr, left) - (std::shared_ptr, right) - (storm::ir::expressions::BinaryBooleanFunctionExpression::FunctorType, functor) -) - #endif /* BINARYBOOLEANFUNCTIONEXPRESSION_H_ */ diff --git a/src/ir/expressions/BinaryNumericalFunctionExpression.h b/src/ir/expressions/BinaryNumericalFunctionExpression.h index 0a8b7cffe..5b928768e 100644 --- a/src/ir/expressions/BinaryNumericalFunctionExpression.h +++ b/src/ir/expressions/BinaryNumericalFunctionExpression.h @@ -53,11 +53,4 @@ public: } -BOOST_FUSION_ADAPT_STRUCT( - storm::ir::expressions::BinaryNumericalFunctionExpression, - (std::shared_ptr, left) - (std::shared_ptr, right) - (storm::ir::expressions::BinaryNumericalFunctionExpression::FunctorType, functor) -) - #endif /* BINARYFUNCTIONEXPRESSION_H_ */ diff --git a/src/ir/expressions/BinaryRelationExpression.h b/src/ir/expressions/BinaryRelationExpression.h index 8ab6aba44..625b801f5 100644 --- a/src/ir/expressions/BinaryRelationExpression.h +++ b/src/ir/expressions/BinaryRelationExpression.h @@ -54,11 +54,4 @@ public: } -BOOST_FUSION_ADAPT_STRUCT( - storm::ir::expressions::BinaryRelationExpression, - (std::shared_ptr, left) - (std::shared_ptr, right) - (storm::ir::expressions::BinaryRelationExpression::RelationType, relation) -) - #endif /* BINARYRELATIONEXPRESSION_H_ */ diff --git a/src/ir/expressions/BooleanConstantExpression.h b/src/ir/expressions/BooleanConstantExpression.h index 5d36598b2..a10c2363e 100644 --- a/src/ir/expressions/BooleanConstantExpression.h +++ b/src/ir/expressions/BooleanConstantExpression.h @@ -10,6 +10,8 @@ #include "ConstantExpression.h" +#include + namespace storm { namespace ir { @@ -58,9 +60,4 @@ public: } -BOOST_FUSION_ADAPT_STRUCT( - storm::ir::expressions::BooleanConstantExpression, - (std::string, constantName) -) - #endif /* BOOLEANCONSTANTEXPRESSION_H_ */ diff --git a/src/ir/expressions/BooleanLiteral.h b/src/ir/expressions/BooleanLiteral.h index c2300cded..81950e52a 100644 --- a/src/ir/expressions/BooleanLiteral.h +++ b/src/ir/expressions/BooleanLiteral.h @@ -43,9 +43,4 @@ public: } -BOOST_FUSION_ADAPT_STRUCT( - storm::ir::expressions::BooleanLiteral, - (bool, value) -) - #endif /* BOOLEANLITERAL_H_ */ diff --git a/src/ir/expressions/ConstantExpression.h b/src/ir/expressions/ConstantExpression.h index 38581d1e4..239b3dc68 100644 --- a/src/ir/expressions/ConstantExpression.h +++ b/src/ir/expressions/ConstantExpression.h @@ -39,9 +39,4 @@ public: } -BOOST_FUSION_ADAPT_STRUCT( - storm::ir::expressions::ConstantExpression, - (std::string, constantName) -) - #endif /* CONSTANTEXPRESSION_H_ */ diff --git a/src/ir/expressions/DoubleConstantExpression.h b/src/ir/expressions/DoubleConstantExpression.h index 6969965ae..3a7363a65 100644 --- a/src/ir/expressions/DoubleConstantExpression.h +++ b/src/ir/expressions/DoubleConstantExpression.h @@ -58,9 +58,4 @@ public: } -BOOST_FUSION_ADAPT_STRUCT( - storm::ir::expressions::DoubleConstantExpression, - (std::string, constantName) -) - #endif /* DOUBLECONSTANTEXPRESSION_H_ */ diff --git a/src/ir/expressions/DoubleLiteral.h b/src/ir/expressions/DoubleLiteral.h index d88dbf33b..dbdcf55ca 100644 --- a/src/ir/expressions/DoubleLiteral.h +++ b/src/ir/expressions/DoubleLiteral.h @@ -41,9 +41,4 @@ public: } -BOOST_FUSION_ADAPT_STRUCT( - storm::ir::expressions::DoubleLiteral, - (double, value) -) - #endif /* DOUBLELITERAL_H_ */ diff --git a/src/ir/expressions/IntegerConstantExpression.h b/src/ir/expressions/IntegerConstantExpression.h index d0df521af..5ff4d7f87 100644 --- a/src/ir/expressions/IntegerConstantExpression.h +++ b/src/ir/expressions/IntegerConstantExpression.h @@ -58,9 +58,4 @@ public: } -BOOST_FUSION_ADAPT_STRUCT( - storm::ir::expressions::IntegerConstantExpression, - (std::string, constantName) -) - #endif /* INTEGERCONSTANTEXPRESSION_H_ */ diff --git a/src/ir/expressions/IntegerLiteral.h b/src/ir/expressions/IntegerLiteral.h index bea4c1743..aef509321 100644 --- a/src/ir/expressions/IntegerLiteral.h +++ b/src/ir/expressions/IntegerLiteral.h @@ -39,9 +39,4 @@ public: } -BOOST_FUSION_ADAPT_STRUCT( - storm::ir::expressions::IntegerLiteral, - (int, value) -) - #endif /* INTEGERLITERAL_H_ */ diff --git a/src/ir/expressions/UnaryBooleanFunctionExpression.h b/src/ir/expressions/UnaryBooleanFunctionExpression.h index f1e71e296..893169b51 100644 --- a/src/ir/expressions/UnaryBooleanFunctionExpression.h +++ b/src/ir/expressions/UnaryBooleanFunctionExpression.h @@ -47,10 +47,4 @@ public: } -BOOST_FUSION_ADAPT_STRUCT( - storm::ir::expressions::UnaryBooleanFunctionExpression, - (std::shared_ptr, child) - (storm::ir::expressions::UnaryBooleanFunctionExpression::FunctorType, functor) -) - #endif /* UNARYBOOLEANFUNCTIONEXPRESSION_H_ */ diff --git a/src/ir/expressions/UnaryNumericalFunctionExpression.h b/src/ir/expressions/UnaryNumericalFunctionExpression.h index 084fc74d8..f697f35eb 100644 --- a/src/ir/expressions/UnaryNumericalFunctionExpression.h +++ b/src/ir/expressions/UnaryNumericalFunctionExpression.h @@ -47,10 +47,4 @@ public: } -BOOST_FUSION_ADAPT_STRUCT( - storm::ir::expressions::UnaryNumericalFunctionExpression, - (std::shared_ptr, child) - (storm::ir::expressions::UnaryNumericalFunctionExpression::FunctorType, functor) -) - #endif /* UNARYFUNCTIONEXPRESSION_H_ */ diff --git a/src/ir/expressions/VariableExpression.h b/src/ir/expressions/VariableExpression.h index 5eceb7c6b..a6a27fa43 100644 --- a/src/ir/expressions/VariableExpression.h +++ b/src/ir/expressions/VariableExpression.h @@ -41,9 +41,4 @@ public: } -BOOST_FUSION_ADAPT_STRUCT( - storm::ir::expressions::VariableExpression, - (std::string, variableName) -) - #endif /* VARIABLEEXPRESSION_H_ */