Renamed Coalition to more descriptive PlayerCoalition

src/storm-parsers/parser/FormulaParserGrammar.cpp

@@ -134,10 +134,10 @@ namespace storm {
             quantileFormula = (qi::lit("quantile") > qi::lit("(") >> *(quantileBoundVariable) >> stateFormula > qi::lit(")"))[qi::_val = phoenix::bind(&FormulaParserGrammar::createQuantileFormula, phoenix::ref(*this), qi::_1, qi::_2)];
             quantileFormula.name("Quantile formula");
 
-            coalition = (-((identifier[phoenix::push_back(qi::_a, qi::_1)] | qi::uint_[phoenix::push_back(qi::_a, qi::_1)]) % ','))[qi::_val = phoenix::bind(&FormulaParserGrammar::createCoalition, phoenix::ref(*this), qi::_a)];
-            coalition.name("coalition");
+            playerCoalition = (-((identifier[phoenix::push_back(qi::_a, qi::_1)] | qi::uint_[phoenix::push_back(qi::_a, qi::_1)]) % ','))[qi::_val = phoenix::bind(&FormulaParserGrammar::createPlayerCoalition, phoenix::ref(*this), qi::_a)];
+            playerCoalition.name("player coalition");
 
-            gameFormula = (qi::lit("<<") > coalition > qi::lit(">>") > operatorFormula)[qi::_val = phoenix::bind(&FormulaParserGrammar::createGameFormula, phoenix::ref(*this), qi::_1, qi::_2)];
+            gameFormula = (qi::lit("<<") > playerCoalition > qi::lit(">>") > operatorFormula)[qi::_val = phoenix::bind(&FormulaParserGrammar::createGameFormula, phoenix::ref(*this), qi::_1, qi::_2)];
             gameFormula.name("game formula");
 
             stateFormula = (orStateFormula | multiFormula | quantileFormula | gameFormula);
@@ -478,11 +478,11 @@ namespace storm {
             }
         }
 
-        storm::logic::Coalition FormulaParserGrammar::createCoalition(std::vector<boost::variant<std::string, storm::storage::PlayerIndex>> const& playerIds) const {
-            return storm::logic::Coalition(playerIds);
+        storm::logic::PlayerCoalition FormulaParserGrammar::createPlayerCoalition(std::vector<boost::variant<std::string, storm::storage::PlayerIndex>> const& playerIds) const {
+            return storm::logic::PlayerCoalition(playerIds);
         }
 
-        std::shared_ptr<storm::logic::Formula const> FormulaParserGrammar::createGameFormula(storm::logic::Coalition const& coalition, std::shared_ptr<storm::logic::Formula const> const& subformula) const {
+        std::shared_ptr<storm::logic::Formula const> FormulaParserGrammar::createGameFormula(storm::logic::PlayerCoalition const& coalition, std::shared_ptr<storm::logic::Formula const> const& subformula) const {
             return std::shared_ptr<storm::logic::Formula const>(new storm::logic::GameFormula(coalition, subformula));
         }
     }

src/storm-parsers/parser/FormulaParserGrammar.h

@@ -163,7 +163,7 @@ namespace storm {
             qi::rule<Iterator, std::shared_ptr<storm::logic::Formula const>(), Skipper> timeOperator;
             qi::rule<Iterator, std::shared_ptr<storm::logic::Formula const>(), Skipper> longRunAverageOperator;
 
-            qi::rule<Iterator, storm::logic::Coalition(), qi::locals<std::vector<boost::variant<std::string, storm::storage::PlayerIndex>>>, Skipper> coalition;
+            qi::rule<Iterator, storm::logic::PlayerCoalition(), qi::locals<std::vector<boost::variant<std::string, storm::storage::PlayerIndex>>>, Skipper> playerCoalition;
 
             qi::rule<Iterator, storm::jani::Property(), Skipper> filterProperty;
             qi::rule<Iterator, std::shared_ptr<storm::logic::Formula const>(), Skipper> simpleFormula;
@@ -208,8 +208,8 @@ namespace storm {
             // Parser that is used to recognize doubles only (as opposed to Spirit's double_ parser).
             boost::spirit::qi::real_parser<double, boost::spirit::qi::strict_real_policies<double>> strict_double;
 
-            storm::logic::Coalition createCoalition(std::vector<boost::variant<std::string, storm::storage::PlayerIndex>> const& playerIds) const;
-            std::shared_ptr<storm::logic::Formula const> createGameFormula(storm::logic::Coalition const& coalition, std::shared_ptr<storm::logic::Formula const> const& subformula) const;
+            storm::logic::PlayerCoalition createPlayerCoalition(std::vector<boost::variant<std::string, storm::storage::PlayerIndex>> const& playerIds) const;
+            std::shared_ptr<storm::logic::Formula const> createGameFormula(storm::logic::PlayerCoalition const& coalition, std::shared_ptr<storm::logic::Formula const> const& subformula) const;
 
             bool areConstantDefinitionsAllowed() const;
             void addConstant(std::string const& name, ConstantDataType type, boost::optional<storm::expressions::Expression> const& expression);

src/storm/logic/GameFormula.cpp

@@ -4,7 +4,7 @@
 
 namespace storm {
     namespace logic {
-        GameFormula::GameFormula(Coalition const& coalition, std::shared_ptr<Formula const> subformula) : UnaryStateFormula(subformula), coalition(coalition) {
+        GameFormula::GameFormula(PlayerCoalition const& coalition, std::shared_ptr<Formula const> subformula) : UnaryStateFormula(subformula), coalition(coalition) {
             // Intentionally left empty.
         }
 
@@ -20,7 +20,7 @@ namespace storm {
             return this->getSubformula().hasQuantitativeResult();
         }
 
-        Coalition const& GameFormula::getCoalition() const {
+        PlayerCoalition const& GameFormula::getCoalition() const {
             return coalition;
         }
         

src/storm/logic/GameFormula.h

@@ -2,20 +2,20 @@
 #define STORM_LOGIC_GAMEFORMULA_H_
 
 #include "storm/logic/UnaryStateFormula.h"
-#include "storm/logic/Coalition.h"
+#include "storm/logic/PlayerCoalition.h"
 #include <memory>
 
 namespace storm {
     namespace logic {
         class GameFormula : public UnaryStateFormula {
         public:
-            GameFormula(Coalition const& coalition, std::shared_ptr<Formula const> subFormula);
+            GameFormula(PlayerCoalition const& coalition, std::shared_ptr<Formula const> subFormula);
 
             virtual ~GameFormula() {
                 // Intentionally left empty.
             }
 
-            Coalition const& getCoalition() const;
+            PlayerCoalition const& getCoalition() const;
             virtual bool isGameFormula() const override;
             virtual bool hasQualitativeResult() const override;
             virtual bool hasQuantitativeResult() const override;
@@ -25,7 +25,7 @@ namespace storm {
             virtual std::ostream& writeToStream(std::ostream& out) const override;
 
         private:
-            Coalition coalition;
+            PlayerCoalition coalition;
         };
     }
 }

src/storm/logic/Coalition.cpp → src/storm/logic/PlayerCoalition.cpp

@@ -1,13 +1,13 @@
-#include "storm/logic/Coalition.h"
+#include "storm/logic/PlayerCoalition.h"
 
 namespace storm {
     namespace logic {
 
-        Coalition::Coalition(std::vector<boost::variant<std::string, storm::storage::PlayerIndex>> playerIds) : _playerIds(playerIds) {
+        PlayerCoalition::PlayerCoalition(std::vector<boost::variant<std::string, storm::storage::PlayerIndex>> playerIds) : _playerIds(playerIds) {
             // Intentionally left empty.
         }
 
-        std::ostream& operator<<(std::ostream& stream, Coalition const& coalition) {
+        std::ostream& operator<<(std::ostream& stream, PlayerCoalition const& coalition) {
             bool firstItem = true;
             for (auto const& id : coalition._playerIds) {
                 if (firstItem) { firstItem = false; } else { stream << ","; }

src/storm/logic/Coalition.h → src/storm/logic/PlayerCoalition.h

@@ -9,13 +9,13 @@
 namespace storm {
     namespace logic {
 
-        class Coalition {
+        class PlayerCoalition {
         public:
-            Coalition() = default;
-            Coalition(std::vector<boost::variant<std::string, storm::storage::PlayerIndex>> playerIds);
-            Coalition(Coalition const& other) = default;
+            PlayerCoalition() = default;
+            PlayerCoalition(std::vector<boost::variant<std::string, storm::storage::PlayerIndex>> playerIds);
+            PlayerCoalition(PlayerCoalition const& other) = default;
 
-            friend std::ostream& operator<<(std::ostream& stream, Coalition const& coalition);
+            friend std::ostream& operator<<(std::ostream& stream, PlayerCoalition const& playerCoalition);
 
         private:
             std::vector<boost::variant<std::string, storm::storage::PlayerIndex>> _playerIds;