Choice.h

Go to the documentation of this file.

#ifndef STORM_GENERATOR_CHOICE_H_
#define STORM_GENERATOR_CHOICE_H_
 
#include <cstdint>
#include <functional>
#include <set>
 
#include <boost/any.hpp>
#include <boost/optional.hpp>
 
#include "storm/storage/Distribution.h"
#include "storm/storage/PlayerIndex.h"
 
namespace storm {
namespace generator {
 
// A structure holding information about a particular choice.
template<typename ValueType, typename StateType = uint32_t>
struct Choice {
   public:
    Choice(uint_fast64_t actionIndex = 0, bool markovian = false);
 
    Choice(Choice const& other) = default;
    Choice& operator=(Choice const& other) = default;
    Choice(Choice&& other) = default;
    Choice& operator=(Choice&& other) = default;
 
    void add(Choice const& other);
 
    StateType sampleFromDistribution(ValueType const& quantile) const;
 
    typename storm::storage::Distribution<ValueType, StateType>::iterator begin();
 
    typename storm::storage::Distribution<ValueType, StateType>::const_iterator begin() const;
 
    typename storm::storage::Distribution<ValueType, StateType>::iterator end();
 
    typename storm::storage::Distribution<ValueType, StateType>::const_iterator end() const;
 
    template<typename ValueTypePrime, typename StateTypePrime>
    friend std::ostream& operator<<(std::ostream& out, Choice<ValueTypePrime, StateTypePrime> const& choice);
 
    void addLabel(std::string const& label);
 
    void addLabels(std::set<std::string> const& labels);
 
    bool hasLabels() const;
 
    std::set<std::string> const& getLabels() const;
 
    void setPlayerIndex(storm::storage::PlayerIndex const& playerIndex);
 
    bool hasPlayerIndex() const;
 
    storm::storage::PlayerIndex const& getPlayerIndex() const;
 
    void addOriginData(boost::any const& data);
 
    bool hasOriginData() const;
 
    boost::any const& getOriginData() const;
 
    uint_fast64_t getActionIndex() const;
 
    ValueType getTotalMass() const;
 
    void addProbability(StateType const& state, ValueType const& value);
 
    void addReward(ValueType const& value);
 
    void addRewards(std::vector<ValueType>&& values);
 
    std::vector<ValueType> const& getRewards() const;
 
    bool isMarkovian() const;
 
    std::size_t size() const;
 
    void reserve(std::size_t const& size);
 
   private:
    // A flag indicating whether this choice is Markovian or not.
    bool markovian;
 
    // The action index associated with this choice.
    uint_fast64_t actionIndex;
 
    // The distribution that is associated with the choice.
    storm::storage::Distribution<ValueType, StateType> distribution;
 
    // The total probability mass (or rates) of this choice.
    ValueType totalMass;
 
    // The reward values associated with this choice.
    std::vector<ValueType> rewards;
 
    // The data that stores what part of the model specification induced this choice
    boost::optional<boost::any> originData;
 
    // The labels of this choice
    boost::optional<std::set<std::string>> labels;
 
    // The playerIndex of this choice
    boost::optional<storm::storage::PlayerIndex> playerIndex;
};
 
template<typename ValueType, typename StateType>
std::ostream& operator<<(std::ostream& out, Choice<ValueType, StateType> const& choice);
 
}  // namespace generator
}  // namespace storm
 
#endif /* STORM_GENERATOR_CHOICE_H_ */