transition_system.h

Go to the documentation of this file.

/*
 * transition_system.h
 *
 * LICENSE HERE
 *
 *  Created on: 2016-08-15
 *      Author: Rick Valenzano
 */

#ifndef TRANSITIONSYSTEM_H_
#define TRANSITIONSYSTEM_H_

#include <vector>

template<class state_t, class action_t>
class TransitionSystem
{
public:
    TransitionSystem();

    virtual ~TransitionSystem();

    virtual bool isApplicable(const state_t &state, const action_t &action) const;

    virtual bool isChildState(const state_t &parent, const state_t &child) const;

    virtual double getActionCost(const state_t &state, const action_t &action) const = 0;

    virtual void applyAction(state_t &state, const action_t &action) const = 0;

    virtual void getActions(const state_t &state, std::vector<action_t> &actions) const = 0;

    virtual void getSuccessors(const state_t &state, std::vector<state_t> &children) const;

    virtual bool isInvertible(const state_t &state, const action_t &action) const;

    virtual action_t getInverse(const state_t &state, const action_t &action) const;

    virtual action_t getDummyAction() const = 0;

    virtual bool isDummyAction(const action_t &action) const = 0;

    bool applyActionSequence(state_t &state, const std::vector<action_t> &actions) const;

    bool isApplicableSequence(const state_t &state, const std::vector<action_t> &actions) const;
};

template<class state_t, class action_t>
TransitionSystem<state_t, action_t>::TransitionSystem()
{
}

template<class state_t, class action_t>
TransitionSystem<state_t, action_t>::~TransitionSystem()
{
}

template<class state_t, class action_t>
bool TransitionSystem<state_t, action_t>::isApplicable(const state_t &state, const action_t &action) const
{
    if(action == getDummyAction())
        return false;

    std::vector<action_t> actions;

    getActions(state, actions);

    for(unsigned i = 0; i < actions.size(); i++) {
        if(action == actions[i])
            return true;
    }

    return false;
}

template<class state_t, class action_t>
bool TransitionSystem<state_t, action_t>::isChildState(const state_t &parent, const state_t &child) const
{
    std::vector<state_t> children;

    getSuccessors(parent, children);

    for(unsigned i = 0; i < children.size(); i++) {
        if(child == children[i])
            return true;
    }

    return false;
}

template<class state_t, class action_t>
void TransitionSystem<state_t, action_t>::getSuccessors(const state_t &state, std::vector<state_t> &children) const
{
    std::vector<action_t> actions;

    getActions(state, actions);

    for(unsigned i = 0; i < actions.size(); i++) {
        state_t state_copy(state);
        applyAction(state_copy, actions[i]);

        children.push_back(state_copy);
    }
}

template<class state_t, class action_t>
bool TransitionSystem<state_t, action_t>::isInvertible(const state_t &state, const action_t &action) const {
    return false;
}

template<class state_t, class action_t>
action_t TransitionSystem<state_t, action_t>::getInverse(const state_t &state, const action_t &action) const {
    return getDummyAction();
}


template<class state_t, class action_t>
bool TransitionSystem<state_t, action_t>::applyActionSequence(state_t &state,
        const std::vector<action_t> &actions) const
{
    for(unsigned i = 0; i < actions.size(); i++) {
        if(!isApplicable(state, actions[i]))
            return false;
        applyGivenAction(state, actions[i]);
    }

    return true;
}

template<class state_t, class action_t>
bool TransitionSystem<state_t, action_t>::isApplicableSequence(const state_t &state,
        const std::vector<action_t> &actions) const
{
    state_t state_copy(state);

    if(!applyActionSequence(state, actions))
        return false;

    return true;
}
#endif /* TRANSITIONSYSTEM_H_ */