Started working on modified property classes.

Former-commit-id: cbcf84c2f6

CMakeLists.txt

@@ -258,6 +258,7 @@ file(GLOB STORM_PROPERTIES_FILES ${PROJECT_SOURCE_DIR}/src/properties/*.h ${PROJ
 file(GLOB_RECURSE STORM_PROPERTIES_CSL_FILES ${PROJECT_SOURCE_DIR}/src/properties/csl/*.h ${PROJECT_SOURCE_DIR}/src/properties/csl/*.cpp)
 file(GLOB_RECURSE STORM_PROPERTIES_LTL_FILES ${PROJECT_SOURCE_DIR}/src/properties/ltl/*.h ${PROJECT_SOURCE_DIR}/src/properties/ltl/*.cpp)
 file(GLOB_RECURSE STORM_PROPERTIES_PRCTL_FILES ${PROJECT_SOURCE_DIR}/src/properties/prctl/*.h ${PROJECT_SOURCE_DIR}/src/properties/prctl/*.cpp)
+file(GLOB_RECURSE STORM_PROPERTIES_LOGIC_FILES ${PROJECT_SOURCE_DIR}/src/properties/logic/*.h ${PROJECT_SOURCE_DIR}/src/properties/logic/*.cpp)
 file(GLOB_RECURSE STORM_PROPERTIES_ACTIONS_FILES ${PROJECT_SOURCE_DIR}/src/properties/actions/*.h ${PROJECT_SOURCE_DIR}/src/properties/actions/*.cpp)
 file(GLOB_RECURSE STORM_MODELCHECKER_FILES ${PROJECT_SOURCE_DIR}/src/modelchecker/*.h ${PROJECT_SOURCE_DIR}/src/modelchecker/*.cpp)
 file(GLOB_RECURSE STORM_COUNTEREXAMPLES_FILES ${PROJECT_SOURCE_DIR}/src/counterexamples/*.h ${PROJECT_SOURCE_DIR}/src/counterexamples/*.cpp)
@@ -290,6 +291,7 @@ source_group(adapters FILES ${STORM_ADAPTERS_FILES})
 source_group(builder FILES ${STORM_BUILDER_FILES})
 source_group(exceptions FILES ${STORM_EXCEPTIONS_FILES})
 source_group(properties FILES ${STORM_PROPERTIES_FILES})
+source_group(properties\\logic FILES ${STORM_PROPERTIES_LOGIC_FILES})
 source_group(properties\\csl FILES ${STORM_PROPERTIES_CSL_FILES})
 source_group(properties\\ltl FILES ${STORM_PROPERTIES_LTL_FILES})
 source_group(properties\\prctl FILES ${STORM_PROPERTIES_PRCTL_FILES})

src/modelchecker/CheckResult.h

@@ -0,0 +1,13 @@
+#ifndef STORM_MODELCHECKER_CHECKRESULT_H_
+#define STORM_MODELCHECKER_CHECKRESULT_H_
+
+namespace storm {
+    namespace modelchecker {
+        // The base class of all check results.
+        class CheckResult {
+            
+        };
+    }
+}
+
+#endif /* STORM_MODELCHECKER_CHECKRESULT_H_ */

src/modelchecker/SparseAllStatesQualitativeCheckResult.h

@@ -0,0 +1,35 @@
+#ifndef STORM_MODELCHECKER_SPARSEALLSTATESQUALITATIVECHECKRESULT_H_
+#define STORM_MODELCHECKER_SPARSEALLSTATESQUALITATIVECHECKRESULT_H_
+
+#include "src/modelchecker/CheckResult.h"
+#include "src/storage/BitVector.h"
+
+namespace storm {
+    namespace modelchecker {
+        template<typename ValueType>
+        class SparseAllStatesQualitativeCheckResult : public CheckResult {
+        public:
+            /*!
+             * Constructs a check result with the provided truth values.
+             *
+             * @param truthValues The truth values of the result.
+             */
+            SparseAllStatesQualitativeCheckResult(storm::storage::BitVector&& truthValues) : truthValues(std::move(truthValues)) {
+                // Intentionally left empty.
+            }
+            
+            SparseAllStatesQualitativeCheckResult(SparseAllStatesQualitativeCheckResult const& other) = default;
+            SparseAllStatesQualitativeCheckResult& operator=(SparseAllStatesQualitativeCheckResult const& other) = default;
+#ifndef WINDOWS
+            SparseAllStatesQualitativeCheckResult(SparseAllStatesQualitativeCheckResult&& other) = default;
+            SparseAllStatesQualitativeCheckResult& operator=(SparseAllStatesQualitativeCheckResult&& other) = default;
+#endif
+            
+        private:
+            // The values of the quantitative check result.
+            storm::storage::BitVector truthValues;
+        };
+    }
+}
+
+#endif /* STORM_MODELCHECKER_SPARSEALLSTATESQUALITATIVECHECKRESULT_H_ */

src/modelchecker/SparseAllStatesQuantitativeCheckResult.h

@@ -0,0 +1,37 @@
+#ifndef STORM_MODELCHECKER_SPARSEALLSTATESQUANTITATIVECHECKRESULT_H_
+#define STORM_MODELCHECKER_SPARSEALLSTATESQUANTITATIVECHECKRESULT_H_
+
+#include <vector>
+
+#include "src/modelchecker/CheckResult.h"
+#include "src/utility/OsDetection.h"
+
+namespace storm {
+    namespace modelchecker {
+        template<typename ValueType>
+        class SparseAllStatesQuantitativeCheckResult : public CheckResult {
+        public:
+            /*!
+             * Constructs a check result with the provided values.
+             *
+             * @param values The values of the result.
+             */
+            SparseAllStatesQuantitativeCheckResult(std::vector<ValueType>&& values) : values(std::move(values)) {
+                // Intentionally left empty.
+            }
+            
+            SparseAllStatesQuantitativeCheckResult(SparseAllStatesQuantitativeCheckResult const& other) = default;
+            SparseAllStatesQuantitativeCheckResult& operator=(SparseAllStatesQuantitativeCheckResult const& other) = default;
+#ifndef WINDOWS
+            SparseAllStatesQuantitativeCheckResult(SparseAllStatesQuantitativeCheckResult&& other) = default;
+            SparseAllStatesQuantitativeCheckResult& operator=(SparseAllStatesQuantitativeCheckResult&& other) = default;
+#endif
+            
+        private:
+            // The values of the quantitative check result.
+            std::vector<ValueType> values;
+        };
+    }
+}
+
+#endif /* STORM_MODELCHECKER_SPARSEALLSTATESQUANTITATIVECHECKRESULT_H_ */

src/properties/logic/AtomicExpressionFormula.h

@@ -0,0 +1,14 @@
+#ifndef STORM_LOGIC_ATOMICEXPRESSIONFORMULA_H_
+#define STORM_LOGIC_ATOMICEXPRESSIONFORMULA_H_
+
+#include "src/properties/logic/StateFormula.h"
+
+namespace storm {
+    namespace logic {
+        class AtomicExpressionFormula : public StateFormula {
+            
+        };
+    }
+}
+
+#endif /* STORM_LOGIC_ATOMICEXPRESSIONFORMULA_H_ */

src/properties/logic/AtomicLabelFormula.h

@@ -0,0 +1,14 @@
+#ifndef STORM_LOGIC_ATOMICLABELFORMULA_H_
+#define STORM_LOGIC_ATOMICLABELFORMULA_H_
+
+#include "src/properties/logic/StateFormula.h"
+
+namespace storm {
+    namespace logic {
+        class AtomicLabelFormula : public StateFormula {
+            
+        };
+    }
+}
+
+#endif /* STORM_LOGIC_ATOMICLABELFORMULA_H_ */

src/properties/logic/BinaryBooleanStateFormula.h

@@ -0,0 +1,14 @@
+#ifndef STORM_LOGIC_BINARYBOOLEANSTATEFORMULA_H_
+#define STORM_LOGIC_BINARYBOOLEANSTATEFORMULA_H_
+
+#include "src/properties/logic/BinaryStateFormula.h"
+
+namespace storm {
+    namespace logic {
+        class BinaryBooleanStateFormula : public BinaryStateFormula {
+            
+        };
+    }
+}
+
+#endif /* STORM_LOGIC_BINARYBOOLEANSTATEFORMULA_H_ */

src/properties/logic/BinaryPathFormula.h

@@ -0,0 +1,14 @@
+#ifndef STORM_LOGIC_BINARYPATHFORMULA_H_
+#define STORM_LOGIC_BINARYPATHFORMULA_H_
+
+#include "src/properties/logic/PathFormula.h"
+
+namespace storm {
+    namespace logic {
+        class BinaryPathFormula : public PathFormula {
+            
+        };
+    }
+}
+
+#endif /* STORM_LOGIC_BINARYPATHFORMULA_H_ */

src/properties/logic/BinaryStateFormula.h

@@ -0,0 +1,14 @@
+#ifndef STORM_LOGIC_BINARYSTATEFORMULA_H_
+#define STORM_LOGIC_BINARYSTATEFORMULA_H_
+
+#include "src/properties/logic/StateFormula.h"
+
+namespace storm {
+    namespace logic {
+        class BinaryStateFormula : public StateFormula {
+            
+        };
+    }
+}
+
+#endif /* STORM_LOGIC_BINARYSTATEFORMULA_H_ */

src/properties/logic/BooleanLiteralFormula.h

@@ -0,0 +1,14 @@
+#ifndef STORM_LOGIC_BOOLEANLITERALFORMULA_H_
+#define STORM_LOGIC_BOOLEANLITERALFORMULA_H_
+
+#include "src/properties/logic/StateFormula.h"
+
+namespace storm {
+    namespace logic {
+        class BooleanLiteralFormula : public StateFormula {
+            
+        };
+    }
+}
+
+#endif /* STORM_LOGIC_BOOLEANLITERALFORMULA_H_ */

src/properties/logic/BoundedUntilFormula.h

@@ -0,0 +1,14 @@
+#ifndef STORM_LOGIC_BOUNDEDUNTILFORMULA_H_
+#define STORM_LOGIC_BOUNDEDUNTILFORMULA_H_
+
+#include "src/properties/logic/BinaryPathFormula.h"
+
+namespace storm {
+    namespace logic {
+        class BoundedUntilFormula : public BinaryPathFormula {
+            
+        };
+    }
+}
+
+#endif /* STORM_LOGIC_BOUNDEDUNTILFORMULA_H_ */

src/properties/logic/ConditionalPathFormula.h

@@ -0,0 +1,14 @@
+#ifndef STORM_LOGIC_CONDITIONALPATHFORMULA_H_
+#define STORM_LOGIC_CONDITIONALPATHFORMULA_H_
+
+#include "src/properties/logic/BinaryPathFormula.h"
+
+namespace storm {
+    namespace logic {
+        class ConditionalPathFormula : public BinaryPathFormula {
+            
+        };
+    }
+}
+
+#endif /* STORM_LOGIC_CONDITIONALPATHFORMULA_H_ */

src/properties/logic/CumulativeRewardFormula.h

@@ -0,0 +1,14 @@
+#ifndef STORM_LOGIC_CUMULATIVEREWARDFORMULA_H_
+#define STORM_LOGIC_CUMULATIVEREWARDFORMULA_H_
+
+#include "src/properties/logic/PathRewardFormula.h"
+
+namespace storm {
+    namespace logic {
+        class CumulativeRewardFormula : public PathRewardFormula {
+            
+        };
+    }
+}
+
+#endif /* STORM_LOGIC_CUMULATIVEREWARDFORMULA_H_ */

src/properties/logic/EventuallyFormula.h

@@ -0,0 +1,14 @@
+#ifndef STORM_LOGIC_EVENTUALLYFORMULA_H_
+#define STORM_LOGIC_EVENTUALLYFORMULA_H_
+
+#include "src/properties/logic/UnaryPathFormula.h"
+
+namespace storm {
+    namespace logic {
+        class EventuallyFormula : public UnaryPathFormula {
+            
+        };
+    }
+}
+
+#endif /* STORM_LOGIC_EVENTUALLYFORMULA_H_ */

src/properties/logic/Formula.cpp

@@ -0,0 +1,297 @@
+#include "src/properties/logic/Formulas.h"
+
+namespace storm {
+    namespace logic {
+        Formula::~Formula() {
+            // Intentionally left empty.
+        }
+        
+        bool Formula::isPathFormula() const {
+            return false;
+        }
+        
+        bool Formula::isStateFormula() const {
+            return false;
+        }
+        
+        bool Formula::isBinaryStateFormula() const {
+            return false;
+        }
+        
+        bool Formula::isUnaryStateFormula() const {
+            return false;
+        }
+        
+        bool Formula::isBinaryBooleanStateFormula() const {
+            return false;
+        }
+        
+        bool Formula::isUnaryBooleanStateFormula() const {
+            return false;
+        }
+        
+        bool Formula::isBooleanLiteralFormula() const {
+            return false;
+        }
+        
+        bool Formula::isAtomicExpressionFormula() const {
+            return false;
+        }
+        
+        bool Formula::isAtomicLabelFormula() const {
+            return false;
+        }
+        
+        bool Formula::isUntilFormula() const {
+            return false;
+        }
+        
+        bool Formula::isBoundedUntilFormula() const {
+            return false;
+        }
+        
+        bool Formula::isEventuallyFormula() const {
+            return false;
+        }
+        
+        bool Formula::isGloballyFormula() const {
+            return false;
+        }
+        
+        bool Formula::isBinaryPathFormula() const {
+            return false;
+        }
+        
+        bool Formula::isUnaryPathFormula() const {
+            return false;
+        }
+        
+        bool Formula::isConditionalPathFormula() const {
+            return false;
+        }
+        
+        bool Formula::isNextFormula() const {
+            return false;
+        }
+        
+        bool Formula::isSteadyStateFormula() const {
+            return false;
+        }
+        
+        bool Formula::isPathRewardFormula() const {
+            return false;
+        }
+        
+        bool Formula::isCumulativeRewardFormula() const {
+            return false;
+        }
+        
+        bool Formula::isInstantaneousRewardFormula() const {
+            return false;
+        }
+        
+        bool Formula::isReachabilityRewardFormula() const {
+            return false;
+        }
+        
+        bool Formula::isProbabilisticOperator() const {
+            return false;
+        }
+        
+        bool Formula::isRewardOperator() const {
+            return false;
+        }
+        
+        PathFormula& Formula::asPathFormula() {
+            return dynamic_cast<PathFormula&>(*this);
+        }
+        
+        PathFormula const& Formula::asPathFormula() const {
+            return dynamic_cast<PathFormula const&>(*this);
+        }
+        
+        StateFormula& Formula::asStateFormula() {
+            return dynamic_cast<StateFormula&>(*this);
+        }
+        
+        StateFormula const& Formula::asStateFormula() const {
+            return dynamic_cast<StateFormula const&>(*this);
+        }
+        
+        BinaryStateFormula& Formula::asBinaryStateFormula() {
+            return dynamic_cast<BinaryStateFormula&>(*this);
+        }
+        
+        BinaryStateFormula const& Formula::asBinaryStateFormula() const {
+            return dynamic_cast<BinaryStateFormula const&>(*this);
+        }
+        
+        UnaryStateFormula& Formula::asUnaryStateFormula() {
+            return dynamic_cast<UnaryStateFormula&>(*this);
+        }
+        
+        UnaryStateFormula const& Formula::asUnaryStateFormula() const {
+            return dynamic_cast<UnaryStateFormula const&>(*this);
+        }
+        
+        ConditionalPathFormula& Formula::asConditionalPathFormula() {
+            return dynamic_cast<ConditionalPathFormula&>(*this);
+        }
+        
+        ConditionalPathFormula const& Formula::asConditionalPathFormula() const {
+            return dynamic_cast<ConditionalPathFormula const&>(*this);
+        }
+        
+        BinaryBooleanStateFormula& Formula::asBinaryBooleanStateFormula() {
+            return dynamic_cast<BinaryBooleanStateFormula&>(*this);
+        }
+        
+        BinaryBooleanStateFormula const& Formula::asBinaryBooleanStateFormula() const {
+            return dynamic_cast<BinaryBooleanStateFormula const&>(*this);
+        }
+        
+        UnaryBooleanStateFormula& Formula::asUnaryBooleanStateFormula() {
+            return dynamic_cast<UnaryBooleanStateFormula&>(*this);
+        }
+        
+        UnaryBooleanStateFormula const& Formula::asUnaryBooleanStateFormula() const {
+            return dynamic_cast<UnaryBooleanStateFormula const&>(*this);
+        }
+        
+        BooleanLiteralFormula& Formula::asBooleanLiteralFormula() {
+            return dynamic_cast<BooleanLiteralFormula&>(*this);
+        }
+        
+        BooleanLiteralFormula const& Formula::asBooleanLiteralFormula() const {
+            return dynamic_cast<BooleanLiteralFormula const&>(*this);
+        }
+        
+        AtomicExpressionFormula& Formula::asAtomicExpressionFormula() {
+            return dynamic_cast<AtomicExpressionFormula&>(*this);
+        }
+        
+        AtomicExpressionFormula const& Formula::asAtomicExpressionFormula() const {
+            return dynamic_cast<AtomicExpressionFormula const&>(*this);
+        }
+        
+        AtomicLabelFormula& Formula::asAtomicLabelFormula() {
+            return dynamic_cast<AtomicLabelFormula&>(*this);
+        }
+        
+        AtomicLabelFormula const& Formula::asAtomicLabelFormula() const {
+            return dynamic_cast<AtomicLabelFormula const&>(*this);
+        }
+        
+        UntilFormula& Formula::asUntilFormula() {
+            return dynamic_cast<UntilFormula&>(*this);
+        }
+        
+        UntilFormula const& Formula::asUntilFormula() const {
+            return dynamic_cast<UntilFormula const&>(*this);
+        }
+        
+        BoundedUntilFormula& Formula::asBoundedUntilFormula() {
+            return dynamic_cast<BoundedUntilFormula&>(*this);
+        }
+        
+        BoundedUntilFormula const& Formula::asBoundedUntilFormula() const {
+            return dynamic_cast<BoundedUntilFormula const&>(*this);
+        }
+        
+        EventuallyFormula& Formula::asEventuallyFormula() {
+            return dynamic_cast<EventuallyFormula&>(*this);
+        }
+        
+        EventuallyFormula const& Formula::asEventuallyFormula() const {
+            return dynamic_cast<EventuallyFormula const&>(*this);
+        }
+        
+        GloballyFormula& Formula::asGloballyFormula() {
+            return dynamic_cast<GloballyFormula&>(*this);
+        }
+        
+        GloballyFormula const& Formula::asGloballyFormula() const {
+            return dynamic_cast<GloballyFormula const&>(*this);
+        }
+        
+        BinaryPathFormula& Formula::asBinaryPathFormula() {
+            return dynamic_cast<BinaryPathFormula&>(*this);
+        }
+        
+        BinaryPathFormula const& Formula::asBinaryPathFormula() const {
+            return dynamic_cast<BinaryPathFormula const&>(*this);
+        }
+        
+        UnaryPathFormula& Formula::asUnaryPathFormula() {
+            return dynamic_cast<UnaryPathFormula&>(*this);
+        }
+        
+        UnaryPathFormula const& Formula::asUnaryPathFormula() const {
+            return dynamic_cast<UnaryPathFormula const&>(*this);
+        }
+        
+        NextFormula& Formula::asNextFormula() {
+            return dynamic_cast<NextFormula&>(*this);
+        }
+        
+        NextFormula const& Formula::asNextFormula() const {
+            return dynamic_cast<NextFormula const&>(*this);
+        }
+        
+        SteadyStateFormula& Formula::asSteadyStateFormula() {
+            return dynamic_cast<SteadyStateFormula&>(*this);
+        }
+        
+        SteadyStateFormula const& Formula::asSteadyStateFormula() const {
+            return dynamic_cast<SteadyStateFormula const&>(*this);
+        }
+        
+        PathRewardFormula& Formula::asPathRewardFormula() {
+            return dynamic_cast<PathRewardFormula&>(*this);
+        }
+        
+        PathRewardFormula const& Formula::asPathRewardFormula() const {
+            return dynamic_cast<PathRewardFormula const&>(*this);
+        }
+        
+        CumulativeRewardFormula& Formula::asCumulativeRewardFormula() {
+            return dynamic_cast<CumulativeRewardFormula&>(*this);
+        }
+        
+        CumulativeRewardFormula const& Formula::asCumulativeRewardFormula() const {
+            return dynamic_cast<CumulativeRewardFormula const&>(*this);
+        }
+        
+        InstantaneousRewardFormula& Formula::asInstantaneousRewardFormula() {
+            return dynamic_cast<InstantaneousRewardFormula&>(*this);
+        }
+        
+        InstantaneousRewardFormula const& Formula::asInstantaneousRewardFormula() const {
+            return dynamic_cast<InstantaneousRewardFormula const&>(*this);
+        }
+        
+        ReachabilityRewardFormula& Formula::asReachabilityRewardFormula() {
+            return dynamic_cast<ReachabilityRewardFormula&>(*this);
+        }
+        
+        ReachabilityRewardFormula const& Formula::asReachabilityRewardFormula() const {
+            return dynamic_cast<ReachabilityRewardFormula const&>(*this);
+        }
+        
+        ProbabilityOperatorFormula& Formula::asProbabilityOperatorFormula() {
+            return dynamic_cast<ProbabilityOperatorFormula&>(*this);
+        }
+        
+        ProbabilityOperatorFormula const& Formula::asProbabilityOperatorFormula() const {
+            return dynamic_cast<ProbabilityOperatorFormula const&>(*this);
+        }
+        
+        RewardOperatorFormula& Formula::asRewardOperatorFormula() {
+            return dynamic_cast<RewardOperatorFormula&>(*this);
+        }
+        
+        RewardOperatorFormula const& Formula::asRewardOperatorFormula() const {
+            return dynamic_cast<RewardOperatorFormula const&>(*this);
+        }
+    }
+}

src/properties/logic/Formula.h

@@ -0,0 +1,148 @@
+#ifndef STORM_LOGIC_FORMULA_H_
+#define STORM_LOGIC_FORMULA_H_
+
+#include <memory>
+
+#include "src/modelchecker/CheckResult.h"
+
+namespace storm {
+    namespace logic {
+        // Forward-declare all formula classes.
+        class PathFormula;
+        class StateFormula;
+        class BinaryStateFormula;
+        class UnaryStateFormula;
+        class BinaryBooleanStateFormula;
+        class UnaryBooleanStateFormula;
+        class BooleanLiteralFormula;
+        class AtomicExpressionFormula;
+        class AtomicLabelFormula;
+        class UntilFormula;
+        class BoundedUntilFormula;
+        class EventuallyFormula;
+        class GloballyFormula;
+        class BinaryPathFormula;
+        class UnaryPathFormula;
+        class ConditionalPathFormula;
+        class NextFormula;
+        class SteadyStateFormula;
+        class PathRewardFormula;
+        class CumulativeRewardFormula;
+        class InstantaneousRewardFormula;
+        class ReachabilityRewardFormula;
+        class ProbabilityOperatorFormula;
+        class RewardOperatorFormula;
+
+        // Also foward-declare base model checker class.
+        class ModelChecker;
+        
+        class Formula {
+        public:
+            // Make the destructor virtual to allow deletion of objects of subclasses via a pointer to this class.
+            virtual ~Formula();
+            
+            // Methods for querying the exact formula type.
+            virtual bool isPathFormula() const;
+            virtual bool isStateFormula() const;
+            virtual bool isBinaryStateFormula() const;
+            virtual bool isUnaryStateFormula() const;
+            virtual bool isBinaryBooleanStateFormula() const;
+            virtual bool isUnaryBooleanStateFormula() const;
+            virtual bool isBooleanLiteralFormula() const;
+            virtual bool isAtomicExpressionFormula() const;
+            virtual bool isAtomicLabelFormula() const;
+            virtual bool isUntilFormula() const;
+            virtual bool isBoundedUntilFormula() const;
+            virtual bool isEventuallyFormula() const;
+            virtual bool isGloballyFormula() const;
+            virtual bool isBinaryPathFormula() const;
+            virtual bool isUnaryPathFormula() const;
+            virtual bool isConditionalPathFormula() const;
+            virtual bool isNextFormula() const;
+            virtual bool isSteadyStateFormula() const;
+            virtual bool isPathRewardFormula() const;
+            virtual bool isCumulativeRewardFormula() const;
+            virtual bool isInstantaneousRewardFormula() const;
+            virtual bool isReachabilityRewardFormula() const;
+            virtual bool isProbabilisticOperator() const;
+            virtual bool isRewardOperator() const;
+
+            PathFormula& asPathFormula();
+            PathFormula const& asPathFormula() const;
+        
+            StateFormula& asStateFormula();
+            StateFormula const& asStateFormula() const;
+            
+            BinaryStateFormula& asBinaryStateFormula();
+            BinaryStateFormula const& asBinaryStateFormula() const;
+            
+            UnaryStateFormula& asUnaryStateFormula();
+            UnaryStateFormula const& asUnaryStateFormula() const;
+            
+            BinaryBooleanStateFormula& asBinaryBooleanStateFormula();
+            BinaryBooleanStateFormula const& asBinaryBooleanStateFormula() const;
+
+            UnaryBooleanStateFormula& asUnaryBooleanStateFormula();
+            UnaryBooleanStateFormula const& asUnaryBooleanStateFormula() const;
+
+            BooleanLiteralFormula& asBooleanLiteralFormula();
+            BooleanLiteralFormula const& asBooleanLiteralFormula() const;
+            
+            AtomicExpressionFormula& asAtomicExpressionFormula();
+            AtomicExpressionFormula const& asAtomicExpressionFormula() const;
+            
+            AtomicLabelFormula& asAtomicLabelFormula();
+            AtomicLabelFormula const& asAtomicLabelFormula() const;
+            
+            UntilFormula& asUntilFormula();
+            UntilFormula const& asUntilFormula() const;
+            
+            BoundedUntilFormula& asBoundedUntilFormula();
+            BoundedUntilFormula const& asBoundedUntilFormula() const;
+            
+            EventuallyFormula& asEventuallyFormula();
+            EventuallyFormula const& asEventuallyFormula() const;
+            
+            GloballyFormula& asGloballyFormula();
+            GloballyFormula const& asGloballyFormula() const;
+            
+            BinaryPathFormula& asBinaryPathFormula();
+            BinaryPathFormula const& asBinaryPathFormula() const;
+            
+            UnaryPathFormula& asUnaryPathFormula();
+            UnaryPathFormula const& asUnaryPathFormula() const;
+            
+            ConditionalPathFormula& asConditionalPathFormula();
+            ConditionalPathFormula const& asConditionalPathFormula() const;
+            
+            NextFormula& asNextFormula();
+            NextFormula const& asNextFormula() const;
+            
+            SteadyStateFormula& asSteadyStateFormula();
+            SteadyStateFormula const& asSteadyStateFormula() const;
+            
+            PathRewardFormula& asPathRewardFormula();
+            PathRewardFormula const& asPathRewardFormula() const;
+            
+            CumulativeRewardFormula& asCumulativeRewardFormula();
+            CumulativeRewardFormula const& asCumulativeRewardFormula() const;
+            
+            InstantaneousRewardFormula& asInstantaneousRewardFormula();
+            InstantaneousRewardFormula const& asInstantaneousRewardFormula() const;
+            
+            ReachabilityRewardFormula& asReachabilityRewardFormula();
+            ReachabilityRewardFormula const& asReachabilityRewardFormula() const;
+            
+            ProbabilityOperatorFormula& asProbabilityOperatorFormula();
+            ProbabilityOperatorFormula const& asProbabilityOperatorFormula() const;
+            
+            RewardOperatorFormula& asRewardOperatorFormula();
+            RewardOperatorFormula const& asRewardOperatorFormula() const;
+            
+        private:
+            // Currently empty.
+        };
+    }
+}
+
+#endif /* STORM_LOGIC_FORMULA_H_ */

src/properties/logic/Formulas.h

@@ -0,0 +1,31 @@
+#include "src/properties/logic/Formula.h"
+#include "src/properties/logic/AtomicExpressionFormula.h"
+#include "src/properties/logic/AtomicLabelFormula.h"
+#include "src/properties/logic/BinaryBooleanStateFormula.h"
+#include "src/properties/logic/BinaryPathFormula.h"
+#include "src/properties/logic/BinaryStateFormula.h"
+#include "src/properties/logic/BooleanLiteralFormula.h"
+#include "src/properties/logic/BoundedUntilFormula.h"
+#include "src/properties/logic/CumulativeRewardFormula.h"
+#include "src/properties/logic/EventuallyFormula.h"
+#include "src/properties/logic/GloballyFormula.h"
+#include "src/properties/logic/InstantaneousRewardFormula.h"
+#include "src/properties/logic/NextFormula.h"
+#include "src/properties/logic/PathFormula.h"
+#include "src/properties/logic/ProbabilityOperatorFormula.h"
+#include "src/properties/logic/ReachabilityRewardFormula.h"
+#include "src/properties/logic/RewardOperatorFormula.h"
+#include "src/properties/logic/StateFormula.h"
+#include "src/properties/logic/SteadyStateFormula.h"
+#include "src/properties/logic/UnaryBooleanStateFormula.h"
+#include "src/properties/logic/UnaryPathFormula.h"
+#include "src/properties/logic/UnaryStateFormula.h"
+#include "src/properties/logic/UntilFormula.h"
+#include "src/properties/logic/ConditionalPathFormula.h"
+
+
+
+
+
+
+

src/properties/logic/GloballyFormula.h

@@ -0,0 +1,14 @@
+#ifndef STORM_LOGIC_GLOBALLYFORMULA_H_
+#define STORM_LOGIC_GLOBALLYFORMULA_H_
+
+#include "src/properties/logic/UnaryPathFormula.h"
+
+namespace storm {
+    namespace logic {
+        class GloballyFormula : public UnaryPathFormula {
+            
+        };
+    }
+}
+
+#endif /* STORM_LOGIC_GLOBALLYFORMULA_H_ */

src/properties/logic/InstantaneousRewardFormula.h

@@ -0,0 +1,14 @@
+#ifndef STORM_LOGIC_INSTANTANEOUSREWARDFORMULA_H_
+#define STORM_LOGIC_INSTANTANEOUSREWARDFORMULA_H_
+
+#include "src/properties/logic/PathRewardFormula.h"
+
+namespace storm {
+    namespace logic {
+        class InstantaneousRewardFormula : public PathRewardFormula {
+            
+        };
+    }
+}
+
+#endif /* STORM_LOGIC_INSTANTANEOUSREWARDFORMULA_H_ */

src/properties/logic/NextFormula.h

@@ -0,0 +1,14 @@
+#ifndef STORM_LOGIC_NEXTFORMULA_H_
+#define STORM_LOGIC_NEXTFORMULA_H_
+
+#include "src/properties/logic/UnaryPathFormula.h"
+
+namespace storm {
+    namespace logic {
+        class NextFormula : public UnaryPathFormula {
+            
+        };
+    }
+}
+
+#endif /* STORM_LOGIC_NEXTFORMULA_H_ */

src/properties/logic/PathFormula.h

@@ -0,0 +1,14 @@
+#ifndef STORM_LOGIC_PATHFORMULA_H_
+#define STORM_LOGIC_PATHFORMULA_H_
+
+#include "src/properties/logic/Formula.h"
+
+namespace storm {
+    namespace logic {
+        class PathFormula : public Formula {
+            
+        };
+    }
+}
+
+#endif /* STORM_LOGIC_PATHFORMULA_H_ */

src/properties/logic/PathRewardFormula.h

@@ -0,0 +1,14 @@
+#ifndef STORM_LOGIC_PATHREWARDFORMULA_H_
+#define STORM_LOGIC_PATHREWARDFORMULA_H_
+
+#include "src/properties/logic/PathFormula.h"
+
+namespace storm {
+    namespace logic {
+        class PathRewardFormula : public PathFormula {
+            
+        };
+    }
+}
+
+#endif /* STORM_LOGIC_PATHREWARDFORMULA_H_ */

src/properties/logic/ProbabilityOperatorFormula.h

@@ -0,0 +1,14 @@
+#ifndef STORM_LOGIC_PROBABILITYOPERATORFORMULA_H_
+#define STORM_LOGIC_PROBABILITYOPERATORFORMULA_H_
+
+#include "src/properties/logic/PathRewardFormula.h"
+
+namespace storm {
+    namespace logic {
+        class ProbabilityOperatorFormula : public Formula {
+            
+        };
+    }
+}
+
+#endif /* STORM_LOGIC_PROBABILITYOPERATORFORMULA_H_ */

src/properties/logic/ReachabilityRewardFormula.h

@@ -0,0 +1,14 @@
+#ifndef STORM_LOGIC_REACHABILITYREWARDFORMULA_H_
+#define STORM_LOGIC_REACHABILITYREWARDFORMULA_H_
+
+#include "src/properties/logic/PathRewardFormula.h"
+
+namespace storm {
+    namespace logic {
+        class ReachabilityRewardFormula : public PathRewardFormula {
+            
+        };
+    }
+}
+
+#endif /* STORM_LOGIC_REACHABILITYREWARDFORMULA_H_ */

src/properties/logic/RewardOperatorFormula.h

@@ -0,0 +1,14 @@
+#ifndef STORM_LOGIC_REWARDOPERATORFORMULA_H_
+#define STORM_LOGIC_REWARDOPERATORFORMULA_H_
+
+#include "src/properties/logic/PathRewardFormula.h"
+
+namespace storm {
+    namespace logic {
+        class RewardOperatorFormula : public Formula {
+            
+        };
+    }
+}
+
+#endif /* STORM_LOGIC_REWARDOPERATORFORMULA_H_ */

src/properties/logic/StateFormula.h

@@ -0,0 +1,14 @@
+#ifndef STORM_LOGIC_STATEFORMULA_H_
+#define STORM_LOGIC_STATEFORMULA_H_
+
+#include "src/properties/logic/Formula.h"
+
+namespace storm {
+    namespace logic {
+        class StateFormula : public Formula {
+            
+        };
+    }
+}
+
+#endif /* STORM_LOGIC_STATEFORMULA_H_ */

src/properties/logic/SteadyStateFormula.h

@@ -0,0 +1,14 @@
+#ifndef STORM_LOGIC_STEADYSTATEFORMULA_H_
+#define STORM_LOGIC_STEADYSTATEFORMULA_H_
+
+#include "src/properties/logic/UnaryStateFormula.h"
+
+namespace storm {
+    namespace logic {
+        class SteadyStateFormula : public UnaryStateFormula {
+            
+        };
+    }
+}
+
+#endif /* STORM_LOGIC_STEADYSTATEFORMULA_H_ */

src/properties/logic/UnaryBooleanStateFormula.h

@@ -0,0 +1,14 @@
+#ifndef STORM_LOGIC_UNARYBOOLEANSTATEFORMULA_H_
+#define STORM_LOGIC_UNARYBOOLEANSTATEFORMULA_H_
+
+#include "src/properties/logic/UnaryStateFormula.h"
+
+namespace storm {
+    namespace logic {
+        class UnaryBooleanStateFormula : public UnaryStateFormula {
+            
+        };
+    }
+}
+
+#endif /* STORM_LOGIC_UNARYBOOLEANSTATEFORMULA_H_ */

src/properties/logic/UnaryPathFormula.h

@@ -0,0 +1,14 @@
+#ifndef STORM_LOGIC_UNARYPATHFORMULA_H_
+#define STORM_LOGIC_UNARYPATHFORMULA_H_
+
+#include "src/properties/logic/PathFormula.h"
+
+namespace storm {
+    namespace logic {
+        class UnaryPathFormula : public PathFormula {
+            
+        };
+    }
+}
+
+#endif /* STORM_LOGIC_UNARYPATHFORMULA_H_ */

src/properties/logic/UnaryStateFormula.h

@@ -0,0 +1,14 @@
+#ifndef STORM_LOGIC_UNARYSTATEFORMULA_H_
+#define STORM_LOGIC_UNARYSTATEFORMULA_H_
+
+#include "src/properties/logic/StateFormula.h"
+
+namespace storm {
+    namespace logic {
+        class UnaryStateFormula : public StateFormula {
+            
+        };
+    }
+}
+
+#endif /* STORM_LOGIC_UNARYSTATEFORMULA_H_ */

src/properties/logic/UntilFormula.h

@@ -0,0 +1,14 @@
+#ifndef STORM_LOGIC_UNTILFORMULA_H_
+#define STORM_LOGIC_UNTILFORMULA_H_
+
+#include "src/properties/logic/BinaryPathFormula.h"
+
+namespace storm {
+    namespace logic {
+        class UntilFormula : public BinaryPathFormula {
+            
+        };
+    }
+}
+
+#endif /* STORM_LOGIC_UNTILFORMULA_H_ */