root/ggpa/Sentence.h

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

#ifndef SENTENCE_H
#define SENTENCE_H

// defined in C++ libraries
//#define BIG_ENDIAN 0
//#define LITTLE_ENDIAN 1

#define ENDIAN LITTLE_ENDIAN
#define DISTINCT_NAME "distinct"


#include "SentenceStructure.h"
#include "Utils.h"
#include <vector>
#include <string>
#include <map>
#include <ostream>
#include <iostream>
using namespace std;

/*
 * Class to represent sentences in the rules, like (cell %x 2 x).  These
 * sentences can include literals and variables, and Sentences will also
 * be used in some cases to hold the dependencies for a sentence
 */
class Sentence {
        
protected:
        // the values for this sentence.  Variables will start with %
        vector<string> values;

        // the subvectors must all be true (AND) to imply this sentence.
        // The subvectors represent OR relations - if there is only one,
        // then it is just a single literal
        vector<vector<Sentence*> > dependencies;
        
        // A dependency flag is true if the dependency is negative - meaning
        // that in the dependency declaration, the dependency was surrounded
        // by a NOT
        vector<bool> dependencyFlags;

        // A reference to the underlying SentenceStructure
        SentenceStructure* structure;

    class PossibleValues {
    protected:
        vector<string>* values;
        
    public:
        PossibleValues() : values(NULL) {}

        PossibleValues(vector<string>* possibleValues);

        virtual ~PossibleValues() {}
        
        /*
         * merge
         * Parameters: otherValues: the values to add to the current
         * No return type
         * Adds the otherValues to these values, avoiding duplication.
         */
        void merge(PossibleValues* otherValues);

        /*
         * getValues
         * no parameters
         * return type: vector<string>*
         * gets the values for this object.
         */
        virtual vector<string>* getValues();
    };

    class DistinctPossibleValues : public PossibleValues {
    public:

        DistinctPossibleValues(vector<string>* possibleValues);

        virtual ~DistinctPossibleValues () {}

        /*
         * getValues
         * no parameters
         * return type: vector<string>*
         * gets the values for this object.
         */
        vector<string>* getValues();
    };

public:

        /*
         * Constructor for Sentence
         * Parameters:  theValues - a vector of values for the Sentence
         *              theStructure - a pointer to a SentenceStructure
         * Return type: none
         * Sets the values of the sentence equal to a copy of theValues,
         * checking that the values are all in the SentenceStructure.
         */
        Sentence(vector<string> theValues, SentenceStructure* theStructure);

   /*
    * Destructor for Sentence class
    */
   virtual ~Sentence();

   /*
    * operator[]
    * Parameters: index - an int representing the value that we wish to 
    *                      retrieve
    * Return type: A const reference to a string
    * Returns the value at the index. This should be used to access the 
    * values in a Sentence.
    */
   const string& operator[](int index) const;

   /*
    * getNumValues
    * No parameters
    * Return type: int
    * Returns the number of values for this sentence.
    */
   unsigned int getNumValues() const;

   /*
    * getName
    * No parameters
    * Return type: string
    * Returns the name of this sentence (from its SentenceStructure)
    */
   string getName() const;

        /*
         * addAndDependency
         * Parameters:  dependency: a Sentence
         *              negated:  a bool, true if the dependency is negative
         * Return value: none
         * Adds the dependency to the dependency list
         */
        void addAndDependency(Sentence* dependency, bool negated);

        /*
         * addOrDependency
         * Parameters: theSentences: a vector of Sentences to be ORed
         *             negated: a bool, true if the dependencyis negative
    * Adds the OR dependency to the dependency list
    */
   void addOrDependency(const vector<Sentence*>& dependency, bool negated);

   /*
    * getDependencies
    * No parameters
    * Return type: a const reference to a vector of vectors of sentences
    * Returns the dependency list for this sentence.
    */
   const vector<vector<Sentence*> >& getDependencies() const;

   /*
    * isDependencyNegated
    * Parameters: index - the index of the dependency in the dependency list
    * Return type: bool
    * Returns true if the dependency is negated, and false otherwise
    */
   bool isDependencyNegated(int index) const;

   /*
    * getIndex
    * No parameters
    * Return type: int
    * Returns the index of this Sentence in the State object.  If this sentence
    * has variables, then the function will return -1.  In this case, you 
    * should call getAtomicSentences and then do getIndex on each of those.
    */
   int getIndex() const;

   /*
    * getAtomicSentences
    * Parameters: none
    * Return type: a vector of sentences
    * Returns all possible atomic sentences that can be derived from this 
    * Sentence.  These sentences will be returned in increasing order of 
    * index within State.
    */
   vector<Sentence*> getAtomicSentences() const;

   /**
    * enumerateWithBinding
    * Parameters: none
    * Return type: a vector of sentence*
    * This works similarly to getAtomicSentences, except that it also does
    * binding within the dependencies.
    */
   vector<Sentence*> enumerateWithBinding() const;

   /**
    * 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
    */
   virtual map<string, vector<string> > getVariables() const;

   /**
    * 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
    */
   virtual Sentence* getAtomicSentence(map<string, string> variableMap) const;

   /*
    * getStructure
    * Parameters: none
    * Return type: a pointer to a SentenceStructure
    * Returns the SentenceStructure for this Sentence
    */
   SentenceStructure* getStructure() const;

   /*
    * operator==
    * Parameters: s2 - another Sentence for comparison
    * Return type: bool
    * Returns true if the two sentences are equal, and false otherwise
    */
   bool operator==(const Sentence& s2) const;
   
   /*
    * clearDependencies
    * No parameters or return type.
    * Removes all of the dependencies
    */
   void clearDependencies(bool recursiveDelete);

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

    /*
     * mergeValues
     * No parameters or return type.
     * Merges possible values for variables in this sentence.
     */
    virtual void mergeValues();

private:
   
   /*
    * enumerateWithBinding
    * Parameters: valueMap - a map of variables to values
    * Return type: vector of sentence pointers
    * Returns the set of sentences that can be generated from this sentence.
    * The supplied variable values will be used, but if no values exist,
    * we will branch on this value.
    */
   vector<Sentence*> enumerateWithBinding(map<string,string>& valueMap) const;

protected:

   /*
    * 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
    */
   virtual void getVariables(map<string, vector<string> >& variableMap) const;

   /*
    * mergeValues
    * Parameters: variableMap:  a multimap from variables to their set of
    *                           possible values
    * Return type: none
    * Merges the sets of values for the variables
    */
   virtual void mergeValues(multimap<string, PossibleValues*>& variableMap);

   /*
    * mergeValue
    * Parameters: value - the value to merge in
    *             valueSet - the set of values for that variable
    *             variableMap - the mapping from variable name to value set
    * Return type: none
    * Merges the value with the valueMap.
    */
   void mergeValue(string value, vector<string>* valueSet, 
                   multimap<string, PossibleValues*>& variableMap);

};

#endif