root/ggpa/SentenceStructure.cpp

/*
 * SentenceStructure.cpp
 * Implementation of SentenceStructure class
 */

#include "SentenceStructure.h"

/*
 * Two argument constructor for SentenceStructure
 * Parameters:   theName - a string containing the name of the new 
 *                      SentenceStructure
 *               numParameters - int containing the number of parameters
 *                               for this SentenceStructure
 *               isActionValue - a boolean representing whether this is an 
 *                               action
 * Sets name to be the parameter name, and creates a new possibleValues
 *    vector of size specified by numParameters
 */
SentenceStructure::SentenceStructure(string theName, int numParameters, 
                                     bool isActionValue) {
    this->name = theName;
    possibleValues.resize(numParameters);
    //possibleValues = new vector<vector<string>* >(numParameters);
    for (int i = 0; i < numParameters; i++) {
        possibleValues[i] = new vector<string>();
    }
    
    // set the references vector to be NULL
    //references.resize(numParameters, NULL);

    this->action = isActionValue;
    offset = -1;
}

/* 
 * getName
 * Parameters:  None
 * Return type: string
 * Returns the name of this SentenceStructure
 */
string SentenceStructure::getName() const {
    return name;
}

/*
 * getNumParameters
 * No parameters
 * Return type: int
 * Returns the number of parameters for this SentenceStructure
 */
unsigned int SentenceStructure::getNumParameters() const {// When different SentenceStructures have parameters that must have the
    //   same values, this is recorded here.
    vector<vector<SentenceStructure*> > counterparts;
    return possibleValues.size();
}

/*
 * getValues
 * Parameters:   num - an int representing the index of the variable we 
 *                     are interested in
 * Return type: a vector of strings representing the set of possible values
 * Gets the set of possible values for the variable at index num.
 */
vector<string>& SentenceStructure::getValues(int num) const {
    return *(possibleValues[num]);
}

/*
 * getValuesPointer
 * Parameters:   num - an int representing the index of the variable we 
 *                     are interested in
 * Return type: a vector of strings representing the set of possible values
 * Gets the set of possible values for the variable at index num.
 */
vector<string>* SentenceStructure::getValuesPointer(int num) const {
    return possibleValues[num];
}

/*
 * getValueIndex
 * Parameters:   num - an int representing the index of the variable we
 *                     are interested in
 *               value - a string representing the value we are searching
 *                       for
 * Return type: int
 * Returns the index of the value in the value set of the numth parameter,
 * or -1 if it is not present.
 */
int SentenceStructure::getValueIndex(int num, string value) const {
    vector<string>::iterator findItr;
    int i = 0;
    for (findItr = possibleValues[num]->begin(); 
         findItr != possibleValues[num]->end(); findItr++, i++) {
        if (*findItr == value) {
            return i;
        }
    }
    return -1;
}

/*
 * addValue
 * Parameters:   num - an int representing the index of the variable we
 *                     are interested in
 *               value - a string containing the new value to add for 
 *                       that variable
 * No return type
 * Adds value to the set of possible values for the variable at index num
 */
void SentenceStructure::addValue(int num, string value) {
    vector<string>::iterator searchItr = possibleValues[num]->begin();
    for (; searchItr != possibleValues[num]->end(); searchItr++) {
        if (*searchItr == value) {
            return;
        }
    }
    
    possibleValues[num]->push_back(value);
    return;
}

/*
 * mergeValues
 * Parameters:   counterpart - another structure with which to merge the
 *                             values for a certain parameter
 *               thisIndex - the index of the parameter in this
 *               thatIndex - the index of the parameter in counterpart
 * Return type: none
 * This function should be used when there is a shared reference between
 * two sentences of different SentenceStructures. These two parameters
 * must thus have the same values, so we want to make it so that they will
 * have the same value set.
 */
/*
void mergeValues(SentenceStructure* counterpart, int thisIndex, 
                 int thatIndex) {
    vector<string>* thisVector = this->possibleValues[thisIndex];
    vector<string>* thatVector = counterpart->possibleValues[thatIndex];

    // if they are already merged, return
    if (thisVector == thatVector) {
        return
    }

    // if thisVector is a reference
    if (this->references[thisIndex] != NULL) {

        // merge the two vectors into thisVector

        // check if thatVector is a reference
        if (counterpart->references[thatIndex] != NULL) {
            // propogate the change
            
        }

    } else {

        // merge the two vectors into thatVector


    }

    
    
    return;
}
*/


/*
 * getOffset
 * No parameters
 * Return type: int
 * Returns the offset for this sentence type for State
 */
int SentenceStructure::getOffset() const {
    return offset;
}

/*
 * setOffset
 * Parameters: theOffset - int containing the new offset for this sentence
 *                      type in the state
 * No return value
 * Sets the offset to the parameter value
 */
void SentenceStructure::setOffset(int theOffset) {
    this->offset = theOffset;
    return;
}

/*
 * isAction
 * No parameters
 * Return type: bool
 * Returns true if this sentence is an Action, and false otherwise
 */
bool SentenceStructure::isAction() const { 
    return action;
}

/*
 * operator ==
 * Parameters:   s2 - another SentenceStructure for comparison
 * Return type: bool
 * Returns true if the two SentenceStructures are equal, and false
 * otherwise.
 */
bool SentenceStructure::operator==(const SentenceStructure& s2) const {
    if (this->name != s2.name) {
        return false;
    }
    if (this->offset != s2.offset) {
        return false;
    }
    if (this->action != s2.action) {
        return false;
    }
    if (this->possibleValues.size() != s2.possibleValues.size()){
        return false;
    }

    for (unsigned int i = 0; i < this->possibleValues.size(); i++) {
        if (this->possibleValues[i] != s2.possibleValues[i]) {
            return false;
        }
    }

    return true;


    
}

/*
 * numPossibleSentences
 * No parameters
 * Returns the number of sentences that could be built on this sentence
 * structure
 */
int SentenceStructure::numPossibleSentences() {
    int total = 1;
    for (unsigned int value = 0; value < possibleValues.size(); value++) {
        total *= possibleValues[value]->size();
    }
    return total;
}

/*
 * print
 * Parameters: output: a stream to output to.
 *             indent: indent on each line
 * No return type.
 * Prints the sentence to the given stream
 */
void SentenceStructure::print(ostream& output, string indent) const {
    output << indent << "(" << name;
    indent = indent + "\t";
    for (unsigned int parameter = 0; parameter < possibleValues.size();
         parameter++) {
        output << endl;
        const vector<string> values = *(possibleValues[parameter]);
        output << indent << "(";
        for (unsigned int index = 0; index < values.size(); index++) {
            output << values[index];
            if (index != values.size() - 1) {
                output << ", ";
            }
        }
        output << ")";
    }
    output << ")" << endl;
}