syntaxtree.h

#ifndef SYNTAXTREE_H
#define SYNTAXTREE_H
#include "Tree.h"
#include "../Grammar Structure/Grammar-with-Map/grammar.h"
//#include "../../../Parser/Tagger/word.h"
//#include "../../../CONFIG/config.h"
#include "syntaxword.h"

typedef std::pair<GrammarPhrase,SyntaxWord> GPSWpair;

struct GSContainerpair{
    GPSWpair _d;

    GSContainerpair(){}

    GSContainerpair(GrammarPhrase g, const SyntaxWord& W){
        _d = GPSWpair(g,W);
    }

    friend std::ostream& operator <<(std::ostream& out, const GSContainerpair& G){
        out << "( " << phraseLookUp[G._d.first] << " , " << G._d.second << " )";
        return out;
    }
};

typedef GSContainerpair GtSpair;

typedef TreeNode<GtSpair> TNpair;

typedef Tree<GtSpair> Tpair;

class SyntaxTree: public Tree<GtSpair>{
private:
    SentenceType _st;
    void recurHead(TNpair* root);
    void recurObj(TNpair* root, const Word &W, SyntaxObject S);
    Word getHeadWord(GrammarPhrase g, TNpair::TNvector W);

    TNpair* findPhrase(TNpair *start, GrammarPhrase find) const;
    void setSubj(TNpair* sentence);
    void setMV(TNpair* sentence);
    void setDO(TNpair* sentence);
    void setIDO(TNpair* sentence);
    void setQ(TNpair* sentence);
    void setAux(TNpair* sentence);
    void setAtt(TNpair *sentence);
    size_t hasDef(TNpair *phrase, GrammarPhrase g);

    void swapSyntax(SyntaxWord& A, SyntaxWord& B);

public:
    SyntaxTree();
    SyntaxTree(TNpair* root);
    SyntaxTree(const SyntaxTree& S);
    SyntaxTree& operator =(const SyntaxTree& S);
    ~SyntaxTree();

    // Public static function
    static string getSyntaxEncoding(const vector<SyntaxWord>& SWord);
    //These are functions for Parser only
    void assignHeads();
    void assignObjects();
    void determineType();

    //Do stuff to current
    //Create child (Must not have any children)
    void addDef(GPlist def);
    void removeDef();
    GPlist getDef();
    GrammarPhrase getPhrase();
    bool atLeaf();
    TNpair* getLastLeaf();
    TNpair* getFirstLeaf();
    TNpair* getChildAt(std::size_t i);
    bool atLastLeaf();
    bool atFirstLeaf();
    std::size_t leavesBefore();
    std::size_t childIndex(TNpair* parent, TNpair* child);

    std::vector<SyntaxWord> getAll() const;
    std::vector<SyntaxWord> getObj(SyntaxObject S) const;
    SentenceType getSentenceType() const;
    SyntaxObject askingFor() const;
};



#endif // SYNTAXTREE_H