root/ggpa/SentenceStructure.h

/*
 * SentenceStructure.h
 * Header file for SentenceStructure class
 */

#ifndef SENTENCE_STRUCTURE_H
#define SENTENCE_STRUCTURE_H
#include <vector>
#include <string>
#include <ostream>
#include <iostream>
using namespace std;

/*
 * Class to hold the general structure of a sentence type.  It will have all 
 * the values for every sentence type.  For example, in the tic-tac-toe game,
 * for "cell" this class will have the values set {{1, 2, 3}, {1, 2, 3}, 
 * {o, x, b}}
 */
class SentenceStructure {
    
private:

    // the name of the operator
    string name;

    // Holds the set of possible values for each variable
    vector<vector<string>* > possibleValues;

    // Indicates if the value list for the ith parameter is a reference
    //vector<SentenceStructure*> references;

    // The offset of this sentence type in the State object
    int offset;

    // true if this sentence represents an Action, false otherwise
    bool action;

    

public:

    /*
     * 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(string theName, int numParameters, bool isActionValue);

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

    /*
     * getNumParameters
     * No parameters
     * Return type: int
     * Returns the number of parameters for this SentenceStructure
     */
    unsigned int getNumParameters() const;

    /*
     * 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>& getValues(int num) const;

    /*
     * 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>* getValuesPointer(int num) const;

    /*
     * 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 getValueIndex(int num, string value) const;

    /*
     * 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 addValue(int num, string value);

    /*
     * 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);

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

    /*
     * 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 setOffset(int theOffset);


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

    /*
     * operator ==
     * Parameters:   s2 - another SentenceStructure for comparison
     * Return type: bool
     * Returns true if the two SentenceStructures are equal, and false
     * otherwise.
     */
    bool operator==(const SentenceStructure& s2) const;

    /*
     * numPossibleSentences
     * No parameters
     * Returns the number of sentences that could be built on this sentence
     * structure
     */
    int numPossibleSentences();

    /*
     * print
     * Parameters: output: a stream to output to.
     *             indent: indent on each line
     * No return type.
     * Prints the sentence to the given stream
     */
    void print(ostream& output = cout, string indent = "") const;

};

#endif