IO.hpp

Go to the documentation of this file.

#ifndef AI_TOOLBOX_POMDP_IO_HEADER_FILE
#define AI_TOOLBOX_POMDP_IO_HEADER_FILE
 
#include <iostream>
#include <iomanip>
 
#include <AIToolbox/Utils/IO.hpp>
#include <AIToolbox/MDP/IO.hpp>
 
#include <AIToolbox/MDP/Model.hpp>
#include <AIToolbox/POMDP/Types.hpp>
#include <AIToolbox/POMDP/TypeTraits.hpp>
#include <AIToolbox/POMDP/Model.hpp>
#include <AIToolbox/POMDP/SparseModel.hpp>
#include <AIToolbox/POMDP/Policies/Policy.hpp>
 
#include <AIToolbox/Logging.hpp>
 
namespace AIToolbox::POMDP {
    Model<MDP::Model> parseCassandra(std::istream & input);
 
    template <IsModelEigen M>
    std::ostream& operator<<(std::ostream &os, const M & model) {
        // First print the MDP part
        MDP::operator<<(os, model);
 
        write(os, model.getObservationFunction());
        return os;
    }
 
    template <MDP::IsModel M>
    std::istream& operator>>(std::istream &is, Model<M> & m) {
        Model<M> in(m.getO(), m.getS(), m.getA());
 
        if (!MDP::operator>>(is, in)) {
            AI_LOGGER(AI_SEVERITY_ERROR, "Could not read underlying MDP for POMDP Model.");
            return is;
        }
 
        auto observations = in.getObservationFunction();
        if (!read(is, observations)) {
            AI_LOGGER(AI_SEVERITY_ERROR, "Could not read Model<M> observation function.");
            return is;
        } else {
            try {
                in.setObservationFunction(observations);
            } catch (const std::invalid_argument &) {
                AI_LOGGER(AI_SEVERITY_ERROR, "The observation function for Model<M> did not contain valid probabilities.");
                is.setstate(std::ios::failbit);
                return is;
            }
        }
 
        m = std::move(in);
 
        return is;
    }
 
    template <MDP::IsModel M>
    std::istream& operator>>(std::istream &is, SparseModel<M> & m) {
        SparseModel<M> in(m.getO(), m.getS(), m.getA());
 
        if (!MDP::operator>>(is, in)) {
            AI_LOGGER(AI_SEVERITY_ERROR, "Could not read underlying MDP for POMDP Model.");
            return is;
        }
 
        auto observations = in.getObservationFunction();
        if (!read(is, observations)) {
            AI_LOGGER(AI_SEVERITY_ERROR, "Could not read SparseModel<M> observation function.");
            return is;
        } else {
            try {
                in.setObservationFunction(observations);
            } catch (const std::invalid_argument &) {
                AI_LOGGER(AI_SEVERITY_ERROR, "The observation function for SparseModel<M> did not contain valid probabilities.");
                is.setstate(std::ios::failbit);
                return is;
            }
        }
 
        m = std::move(in);
 
        return is;
    }
 
    std::ostream& operator<<(std::ostream &os, const Policy & p);
 
    std::istream& operator>>(std::istream &is, Policy & p);
}
 
#endif