converter.h

#ifndef CONVERTER_H
#define CONVERTER_H
#include <string>
#include <list>
#include <QtSql>
#include <sstream>

#include "../Tokenizer/stokenize.h"
#include "config.h"
#include "word.h"

using namespace std;

namespace NLP
{

    class Converter
    {
        private:
            string      mSentence;          // original sentence
            list<Token> mTokens;            // store all essential tokens to be processed

            static QSqlDatabase mDb;

            // Helper function
            void          extractTokens();
            set<WordType> getWordTypes(string wordname, size_t recurDepth = 0);

        public:
            Converter(const string& sentence);

            list<Word>  getWords();
            ~Converter();
    };

    QSqlDatabase Converter::mDb = QSqlDatabase::addDatabase("QSQLITE");

    Converter::Converter(const string &sentence) :
        mSentence(sentence)
    {
        extractTokens(); // extract tokens
        mDb.setDatabaseName(DB_PATH); // database in main project
        if( !mDb.open() ) {
            qDebug() << mDb.lastError();
            qFatal( "Failed to connect to database." );
            throw std::invalid_argument("Error: Invalid database");
        } else { qDebug() << "Debug: Database opened." << endl; }
    }


    void Converter::extractTokens()
    {
        STokenize mySTokenize(mSentence);
        while (mySTokenize.More()) {
            mTokens.push_back(mySTokenize.nextToken());
        }
    }

    set<WordType> Converter::getWordTypes(string wordname, size_t recurDepth)
    {

        QSqlQuery       mLiteQr;
        string          qrStr = "SELECT DISTINCT wordtype FROM entries WHERE word = '" + wordname + "'";
        string          rawTypesCollections;
        set<string>     uniqueWT; // Create vector to hold our words

        mLiteQr.prepare(qrStr.c_str());
        if( !mLiteQr.exec() ) {
            qDebug() << mLiteQr.lastError();
            throw std::invalid_argument("Invalid query.");
         }

        QSqlRecord rec = mLiteQr.record();
        while( mLiteQr.next() ) {
            rawTypesCollections += string(" "); 
            rawTypesCollections += mLiteQr.value(0).toString().toStdString();
        }

        if (rawTypesCollections.empty() && wordname.length() > 1 && recurDepth < 3) {
//            cout << "len WT of " << wordname << " : " << rawTypesCollections.length() << endl;
//            cout << " calling recursive for : " << wordname << endl;
            return getWordTypes(wordname.substr(0, wordname.length() - 1), recurDepth + 1);
        }

        rawTypesCollections.erase(std::remove(rawTypesCollections.begin(),
                                              rawTypesCollections.end(), ',')
                                  , rawTypesCollections.end());
        rawTypesCollections.erase(std::remove(rawTypesCollections.begin(),
                                              rawTypesCollections.end(), '&')
                                  , rawTypesCollections.end());
        string       buf; // Have a buffer string
        stringstream ss(rawTypesCollections); // Insert the string into a stream

        while (ss >> buf)
            uniqueWT.insert(buf);

        set<WordType>   WordTypes;
        for(string WT : uniqueWT)
            WordTypes.insert(WordTypeMap[WT]);
        return WordTypes;
    }

    list<Word> Converter::getWords()
    {
        // NOTE : Move database declaration here

        list<Word>          WordList;
        set <WordType>      foundTypes;

        // try filling rolesj
        for(Token token : mTokens)
        {
            if(token.getType() == TokenType::ALPHA) {         
                string wordStr = token.getTokenString();      
                STokenize::capitalize(wordStr);               
                foundTypes = getWordTypes(wordStr);           
                WordList.push_back(Word(token, foundTypes));  

//                cout << wordStr << " : ";
//                for(auto WordType : foundTypes)
//                    cout << WordStringMap[WordType] << ",";
//                cout << endl;
            }
        }
        // printing all roles

        return WordList;
    }

    Converter::~Converter()
    {
    }

} /* NLP */

#endif /* !CONVERTER_H */