transitions.cpp

Go to the documentation of this file.

#include <transitions.h>


std::ostream& operator<<(std::ostream &out, const TransitionList &t)
{
        for ( TransitionList::const_iterator transition=t.begin() ; transition != t.end(); ++transition ) {
                out << transition->prev_state_ << std::endl;
                out << transition->action_ << std::endl;
                
                PredicateGroup prec_group_next_state(transition->next_state_);
                prec_group_next_state.add_positive_differences(PredicateGroup(transition->prev_state_));
                out << prec_group_next_state << std::endl;
                
                out << "1" << std::endl;
        }
        return out;
}

std::ostream& operator<<(std::ostream &out, const Transition &t)
{
    out << t.prev_state_ << std::endl;
    out << t.action_ << std::endl;
    out << t.next_state_ << std::endl;
    return out;
}

void write_transitions_to_file(TransitionList transitions, std::string file_path)
{
        std::ofstream transitions_file(file_path.c_str());
        if (transitions_file.is_open())
        {
                transitions_file << transitions;
        }
        else
                ROS_ERROR_STREAM("Couldn't write transitions to " << file_path);
        transitions_file.close();
}


TransitionList read_transitions_from_file(std::string file_path)
{
        TransitionList transitions;
        std::ifstream transitions_file(file_path.c_str());
        if (transitions_file.is_open())
        {
                std::string line_prev, line_action, line_next, line_aux;
                
                while ( transitions_file.good() )
                {
                        getline (transitions_file,line_prev);
                        getline (transitions_file,line_action);
                        getline (transitions_file,line_next);
                        getline (transitions_file,line_aux);
                        
                        Transition transition(line_prev, 
                                              get_symbol_from_string(line_action), 
                                              line_next);
                        
                        // avoid adding twice last transition
                        if (transitions_file.good()) {
                                transitions.push_back(transition);
                        }
                }
        }
        else {
                ROS_ERROR_STREAM("Couldn't read transitions from " << file_path);
        }
        transitions_file.close();
        return transitions;
}

void Transition::remove_unused_predicates()
{
        std::stringstream ss;
        PredicateGroup pred_group_prev_state(this->prev_state_);
        pred_group_prev_state.remove_variables_not_present(this->action_.param_names_);
        ss << pred_group_prev_state;
        this->prev_state_ = ss.str();
        
        PredicateGroup pred_group_next_state(this->next_state_);
        pred_group_next_state.remove_variables_not_present(this->action_.param_names_);
        ss.str("");
        ss << pred_group_next_state;
        this->next_state_ = ss.str();
}

TransitionList remove_unused_predicates(const TransitionList transitions)
{
        TransitionList result(transitions);
        for ( TransitionList::iterator transition=result.begin() ; transition != result.end(); ++transition ) {
                transition->remove_unused_predicates();
        }
        return result;
}