Added static asserts to ensure that sub formulas are formulas ;)

src/formula/abstract/And.h

@@ -12,6 +12,7 @@
 #include "src/formula/AbstractFormulaChecker.h"
 #include "src/modelchecker/ForwardDeclarations.h"
 #include <string>
+#include <type_traits>
 
 namespace storm {
 namespace property {
@@ -38,6 +39,10 @@ namespace abstract {
 template <class T, class FormulaType>
 class And : public virtual AbstractFormula<T> {
 
+	// Throw a compiler error when FormulaType is not a subclass of AbstractFormula.
+	static_assert(std::is_base_of<AbstractFormula<T>, FormulaType>::value,
+				  "Instantiaton of FormulaType for storm::property::abstract::And<T,FormulaType> has to be a subtype of storm::property::abstract::AbstractFormula<T>");
+
 public:
 	/*!
 	 * Empty constructor.

src/formula/abstract/BoundedEventually.h

@@ -41,6 +41,10 @@ namespace abstract {
 template <class T, class FormulaType>
 class BoundedEventually : public virtual AbstractFormula<T> {
 
+	// Throw a compiler error when FormulaType is not a subclass of AbstractFormula.
+	static_assert(std::is_base_of<AbstractFormula<T>, FormulaType>::value,
+				  "Instantiaton of FormulaType for storm::property::abstract::BoundedEventually<T,FormulaType> has to be a subtype of storm::property::abstract::AbstractFormula<T>");
+
 public:
 	/*!
 	 * Empty constructor

src/formula/abstract/BoundedNaryUntil.h

@@ -45,6 +45,10 @@ namespace abstract {
 template <class T, class FormulaType>
 class BoundedNaryUntil : public virtual AbstractFormula<T> {
 
+	// Throw a compiler error when FormulaType is not a subclass of AbstractFormula.
+	static_assert(std::is_base_of<AbstractFormula<T>, FormulaType>::value,
+				  "Instantiaton of FormulaType for storm::property::abstract::BoundedNaryUntil<T,FormulaType> has to be a subtype of storm::property::abstract::AbstractFormula<T>");
+
 public:
 	/*!
 	 * Empty constructor

src/formula/abstract/BoundedUntil.h

@@ -39,6 +39,10 @@ namespace abstract {
 template <class T, class FormulaType>
 class BoundedUntil : public virtual AbstractFormula<T> {
 
+	// Throw a compiler error when FormulaType is not a subclass of AbstractFormula.
+	static_assert(std::is_base_of<AbstractFormula<T>, FormulaType>::value,
+				  "Instantiaton of FormulaType for storm::property::abstract::BoundedUntil<T,FormulaType> has to be a subtype of storm::property::abstract::AbstractFormula<T>");
+
 public:
 	/*!
 	 * Empty constructor

src/formula/abstract/Eventually.h

@@ -38,6 +38,10 @@ namespace abstract {
 template <class T, class FormulaType>
 class Eventually : public virtual AbstractFormula<T> {
 
+	// Throw a compiler error when FormulaType is not a subclass of AbstractFormula.
+	static_assert(std::is_base_of<AbstractFormula<T>, FormulaType>::value,
+				  "Instantiaton of FormulaType for storm::property::abstract::Eventually<T,FormulaType> has to be a subtype of storm::property::abstract::AbstractFormula<T>");
+
 public:
 	/*!
 	 * Empty constructor

src/formula/abstract/Globally.h

@@ -39,6 +39,10 @@ namespace abstract {
 template <class T, class FormulaType>
 class Globally : public virtual AbstractFormula<T> {
 
+	// Throw a compiler error when FormulaType is not a subclass of AbstractFormula.
+	static_assert(std::is_base_of<AbstractFormula<T>, FormulaType>::value,
+				  "Instantiaton of FormulaType for storm::property::abstract::Globally<T,FormulaType> has to be a subtype of storm::property::abstract::AbstractFormula<T>");
+
 public:
 	/*!
 	 * Empty constructor

src/formula/abstract/Next.h

@@ -38,6 +38,10 @@ namespace abstract {
 template <class T, class FormulaType>
 class Next : public virtual AbstractFormula<T> {
 
+	// Throw a compiler error when FormulaType is not a subclass of AbstractFormula.
+	static_assert(std::is_base_of<AbstractFormula<T>, FormulaType>::value,
+				  "Instantiaton of FormulaType for storm::property::abstract::Next<T,FormulaType> has to be a subtype of storm::property::abstract::AbstractFormula<T>");
+
 public:
 	/*!
 	 * Empty constructor

src/formula/abstract/Not.h

@@ -36,6 +36,10 @@ namespace abstract {
 template <class T, class FormulaType>
 class Not : public virtual AbstractFormula<T> {
 
+	// Throw a compiler error if FormulaType is not a subclass of AbstractFormula.
+	static_assert(std::is_base_of<AbstractFormula<T>, FormulaType>::value,
+				  "Instantiaton of FormulaType for storm::property::abstract::Not<T,FormulaType> has to be a subtype of storm::property::abstract::AbstractFormula<T>");
+
 public:
 	/*!
 	 * Empty constructor

src/formula/abstract/Or.h

@@ -36,6 +36,10 @@ namespace abstract {
 template <class T, class FormulaType>
 class Or : public virtual AbstractFormula<T> {
 
+	// Throw a compiler error if FormulaType is not a subclass of AbstractFormula.
+	static_assert(std::is_base_of<AbstractFormula<T>, FormulaType>::value,
+				  "Instantiaton of FormulaType for storm::property::abstract::Or<T,FormulaType> has to be a subtype of storm::property::abstract::AbstractFormula<T>");
+
 public:
 	/*!
 	 * Empty constructor.

src/formula/abstract/PathBoundOperator.h

@@ -48,6 +48,10 @@ namespace abstract {
 template<class T, class FormulaType>
 class PathBoundOperator : public virtual AbstractFormula<T>, public OptimizingOperator {
 
+	// Throw a compiler error if FormulaType is not a subclass of AbstractFormula.
+	static_assert(std::is_base_of<AbstractFormula<T>, FormulaType>::value,
+				  "Instantiaton of FormulaType for storm::property::abstract::PathBoundOperator<T,FormulaType> has to be a subtype of storm::property::abstract::AbstractFormula<T>");
+
 public:
 	/*!
 	 * Constructor for non-optimizing operator.

src/formula/abstract/PathNoBoundOperator.h

@@ -51,6 +51,12 @@ namespace abstract {
  */
 template <class T, class FormulaType>
 class PathNoBoundOperator: public virtual AbstractFormula<T>, public OptimizingOperator {
+
+	// Throw a compiler error if FormulaType is not a subclass of AbstractFormula.
+	static_assert(std::is_base_of<AbstractFormula<T>, FormulaType>::value,
+				  "Instantiaton of FormulaType for storm::property::abstract::PathNoBoundOperator<T,FormulaType> has to be a subtype of storm::property::abstract::AbstractFormula<T>");
+
+
 public:
 	/*!
 	 * Empty constructor

src/formula/abstract/ProbabilisticBoundOperator.h

@@ -44,6 +44,10 @@ namespace abstract {
 template<class T, class FormulaType>
 class ProbabilisticBoundOperator : public PathBoundOperator<T, FormulaType> {
 
+	// Throw a compiler error if FormulaType is not a subclass of AbstractFormula.
+	static_assert(std::is_base_of<AbstractFormula<T>, FormulaType>::value,
+				  "Instantiaton of FormulaType for storm::property::abstract::ProbabilisticBoundOperator<T,FormulaType> has to be a subtype of storm::property::abstract::AbstractFormula<T>");
+
 public:
 	/*!
 	 * Empty constructor

src/formula/abstract/ProbabilisticNoBoundOperator.h

@@ -49,6 +49,11 @@ namespace abstract {
  */
 template <class T, class FormulaType>
 class ProbabilisticNoBoundOperator: public PathNoBoundOperator<T, FormulaType> {
+
+	// Throw a compiler error if FormulaType is not a subclass of AbstractFormula.
+	static_assert(std::is_base_of<AbstractFormula<T>, FormulaType>::value,
+				  "Instantiaton of FormulaType for storm::property::abstract::ProbabilisticNoBoundOperator<T,FormulaType> has to be a subtype of storm::property::abstract::AbstractFormula<T>");
+
 public:
 	/*!
 	 * Empty constructor

src/formula/abstract/RewardBoundOperator.h

@@ -39,6 +39,10 @@ namespace abstract {
 template<class T, class FormulaType>
 class RewardBoundOperator : public PathBoundOperator<T, FormulaType> {
 
+	// Throw a compiler error if FormulaType is not a subclass of AbstractFormula.
+	static_assert(std::is_base_of<AbstractFormula<T>, FormulaType>::value,
+				  "Instantiaton of FormulaType for storm::property::abstract::RewardBoundOperator<T,FormulaType> has to be a subtype of storm::property::abstract::AbstractFormula<T>");
+
 public:
 	/*!
 	 * Empty constructor

src/formula/abstract/RewardNoBoundOperator.h

@@ -48,6 +48,11 @@ namespace abstract {
  */
 template <class T, class FormulaType>
 class RewardNoBoundOperator: public PathNoBoundOperator<T, FormulaType> {
+
+	// Throw a compiler error if FormulaType is not a subclass of AbstractFormula.
+	static_assert(std::is_base_of<AbstractFormula<T>, FormulaType>::value,
+				  "Instantiaton of FormulaType for storm::property::abstract::RewardNoBoundOperator<T,FormulaType> has to be a subtype of storm::property::abstract::AbstractFormula<T>");
+
 public:
 	/*!
 	 * Empty constructor

src/formula/abstract/StateBoundOperator.h

@@ -43,6 +43,10 @@ namespace abstract {
 template<class T, class FormulaType>
 class StateBoundOperator : public virtual AbstractFormula<T> {
 
+	// Throw a compiler error if FormulaType is not a subclass of AbstractFormula.
+	static_assert(std::is_base_of<AbstractFormula<T>, FormulaType>::value,
+				  "Instantiaton of FormulaType for storm::property::abstract::StateBoundOperator<T,FormulaType> has to be a subtype of storm::property::abstract::AbstractFormula<T>");
+
 public:
 
 	/*!

src/formula/abstract/StateNoBoundOperator.h

@@ -49,6 +49,11 @@ namespace abstract {
  */
 template <class T, class FormulaType>
 class StateNoBoundOperator: public virtual AbstractFormula<T> {
+
+	// Throw a compiler error if FormulaType is not a subclass of AbstractFormula.
+	static_assert(std::is_base_of<AbstractFormula<T>, FormulaType>::value,
+				  "Instantiaton of FormulaType for storm::property::abstract::StateNoBoundOperator<T,FormulaType> has to be a subtype of storm::property::abstract::AbstractFormula<T>");
+
 public:
 	/*!
 	 * Empty constructor

src/formula/abstract/SteadyStateBoundOperator.h

@@ -32,6 +32,10 @@ namespace abstract {
 template <class T, class FormulaType>
 class SteadyStateBoundOperator : public StateBoundOperator<T, FormulaType> {
 
+	// Throw a compiler error if FormulaType is not a subclass of AbstractFormula.
+	static_assert(std::is_base_of<AbstractFormula<T>, FormulaType>::value,
+				  "Instantiaton of FormulaType for storm::property::abstract::SteadyStateBoundOperator<T,FormulaType> has to be a subtype of storm::property::abstract::AbstractFormula<T>");
+
 public:
 	/*!
 	 * Empty constructor

src/formula/abstract/SteadyStateNoBoundOperator.h

@@ -29,6 +29,11 @@ namespace abstract {
  */
 template <class T, class FormulaType>
 class SteadyStateNoBoundOperator: public StateNoBoundOperator<T, FormulaType> {
+
+	// Throw a compiler error if FormulaType is not a subclass of AbstractFormula.
+	static_assert(std::is_base_of<AbstractFormula<T>, FormulaType>::value,
+				  "Instantiaton of FormulaType for storm::property::abstract::SteadyStateNoBoundOperator<T,FormulaType> has to be a subtype of storm::property::abstract::AbstractFormula<T>");
+
 public:
 	/*!
 	 * Empty constructor

src/formula/abstract/TimeBoundedEventually.h

@@ -25,6 +25,11 @@ namespace abstract {
  */
 template<class T, class FormulaType>
 class TimeBoundedEventually: public storm::property::abstract::TimeBoundedOperator<T> {
+
+	// Throw a compiler error if FormulaType is not a subclass of AbstractFormula.
+	static_assert(std::is_base_of<AbstractFormula<T>, FormulaType>::value,
+				  "Instantiaton of FormulaType for storm::property::abstract::TimeBoundedEventually<T,FormulaType> has to be a subtype of storm::property::abstract::AbstractFormula<T>");
+
 public:
 	/**
 	 * Simple constructor: Only sets the bounds

src/formula/abstract/TimeBoundedUntil.h

@@ -25,6 +25,11 @@ namespace abstract {
  */
 template <class T, class FormulaType>
 class TimeBoundedUntil: public TimeBoundedOperator<T> {
+
+	// Throw a compiler error if FormulaType is not a subclass of AbstractFormula.
+	static_assert(std::is_base_of<AbstractFormula<T>, FormulaType>::value,
+				  "Instantiaton of FormulaType for storm::property::abstract::TimeBoundedUntil<T,FormulaType> has to be a subtype of storm::property::abstract::AbstractFormula<T>");
+
 public:
 	/**
 	 * Constructor providing bounds only;

src/formula/abstract/Until.h

@@ -38,6 +38,10 @@ namespace abstract {
 template <class T, class FormulaType>
 class Until : public virtual AbstractFormula<T> {
 
+	// Throw a compiler error if FormulaType is not a subclass of AbstractFormula.
+	static_assert(std::is_base_of<AbstractFormula<T>, FormulaType>::value,
+				  "Instantiaton of FormulaType for storm::property::abstract::Until<T,FormulaType> has to be a subtype of storm::property::abstract::AbstractFormula<T>");
+
 public:
 	/*!
 	 * Empty constructor