root/ggpa/Action.cpp

/*
 * Action.cpp
 * Implementation of the Action class
 */

#include <stdlib.h>
#include "Action.h"
#include <vector>
#include <iostream>
using namespace std;

Action::Action(vector<string> theValues, SentenceStructure* theStructure,
               string theActor, const vector<string>& actors)
    : Sentence(theValues, theStructure) {
    if (!(theStructure->isAction())) {
        cerr << "The structure does not correspond to an action." << endl;
        exit(1);
    }
    actor = theActor;
    possibleActors = actors;
}

Action::Action(const Action &action) : Sentence(action)
{
    this->actor = action.actor;
}


/*
 * getActor
 * No parameters
 * Return type: string
 * Returns the name of the player that does this action
 */
string Action::getActor() const {
    return this->actor;
}

/*
 * setActor
 * Parameters: theActor - the name of the player that does this action
 * Return type: none
 * Sets the actor to be theActor
 */
void Action::setActor(string theActor) {
    this->actor = theActor;
}


/**
 * getVariables
 * No parameters.
 * Return type: a map from variables to vectors of of their possible values
 * Searches through the sentence and its dependencies, and returns all
 * of the variables, along with their posible values
 */
map<string, vector<string> > Action::getVariables() const {
    return Sentence::getVariables();
}


vector<double> Action::toInputs() const {
    // dummy implementation for compilation
    vector<double> inputs(getStructure()->getNumParameters());
    for (unsigned int parameter = 0; 
         parameter < getStructure()->getNumParameters(); parameter++) {
        string value = (*this)[parameter];
        int valueIndex = getStructure()->getValueIndex(parameter, value);

        if (valueIndex == -1) {
            cerr << "Invalid Action:  parameter " << value 
                 << " is either a variable, or not a valid value for parameter " 
                 << parameter << endl;
            exit(1);
        }

        int numValues = getStructure()->getValues(parameter).size();
        double ratio = valueIndex / (double) numValues;
        inputs[parameter] = ratio;
    }
    return inputs;
}

/*
 * inputSize
 *
 * Parameters: None
 * Return value: int
 * Returns the number of inputs required for a Action.  This is the same
 * as the length of the array returned by the toInputs function. 
 */
int Action::inputSize() const {
    // dummy implementation for compilation
    return getStructure()->getNumParameters();
}

/*
 * getVariables
 * Parameters: variableMap: a map where we should add the new variables
 * Return type: none
 * Adds the variables and their set of possible values to the variableMap
 */
void Action::getVariables(map<string, vector<string> >& variableMap) const {
    Sentence::getVariables(variableMap);
    if (isVariable(actor)) {
        variableMap[actor] = possibleActors;
    }
}

/**
 * getAtomicSentence
 * Parameters: variableMap - a mapping of the variables
 * Return type: a new Sentence
 * Creates a new sentence with any variables mapped by the parameter map
 */
Sentence* Action::getAtomicSentence(map<string, string> variableMap) const {
    return getAtomicAction(variableMap);
}

/**
 * getAtomicAction
 * Parameters: variableMap - a mapping of the variables
 * Return type: a new Sentence
 * Creates a new sentence with any variables mapped by the parameter map
 */
Action* Action::getAtomicAction(map<string, string> variableMap) const {
    Action* atomicSentence = new Action(*this);

    if (isVariable(actor)) {
        atomicSentence->actor = variableMap[actor];
    }

    for (unsigned int valueIndex = 0; 
         valueIndex < atomicSentence->values.size(); 
         valueIndex++) {
        string value = atomicSentence->values[valueIndex];
        if (isVariable(value)) {
            atomicSentence->values[valueIndex] = variableMap[value];
        }
    }

    for (unsigned int dependencyIndex = 0; 
         dependencyIndex < dependencies.size();
         dependencyIndex++) {
        vector<Sentence*> dependency = dependencies[dependencyIndex];
        for (unsigned int sentenceIndex = 0; 
             sentenceIndex < dependency.size();
             sentenceIndex++) {
            Sentence* sentence;
            sentence = dependency[sentenceIndex]->getAtomicSentence(variableMap);
            atomicSentence->dependencies[dependencyIndex][sentenceIndex] = sentence;
            // NOTE:  Do we need to delete the old sentence?
        }
    }

    return atomicSentence;
}

/*
 * operator==
 * Parameters: action - an action to compare to
 * Return type: bool
 * Returns true if the actions are identical, and false otherwise
 */
bool Action::operator==(const Action &action) const {
    if (!(((Sentence)(*this)) == ((Sentence)action))) {
        return false;
    }
    if (this->actor != action.actor) {
        return false;
    }
    return true;
}

/*
 * print
 * Parameters: output: a stream to output to.
 *             indent: indent on each line
 * No return type.
 * Prints the sentence to the given stream
 */
void Action::print(ostream& output, string indent) const {
    output << indent << "Actor: " << actor << endl;
    Sentence::print(output, indent);
}



/*
 * mergeValues
 * Parameters: variableMap:  a multimap from variables to their set of
 *                           possible values
 * Return type: none
 * Merges the sets of values for the variables
 */
void Action::mergeValues(multimap<string, PossibleValues*>& variableMap) {
    // merge in the actor's values
    mergeValue(actor, &possibleActors, variableMap);
    
    // do the rest of the merging
    Sentence::mergeValues(variableMap);
}


/*
 * mergeValues
 * No parameters or return type.
 * Merges possible values for variables in this sentence.
 */
void Action::mergeValues() {
    Sentence::mergeValues();
}