Choice.h

Go to the documentation of this file.

#pragma once
 
#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);

    void reset(uint_fast64_t actionIndex = 0, bool markovian = false);

    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;

    std::vector<ValueType>& getRewards();

    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