converter.h

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

#include "../Tokenizer/stokenize.h"
#include "../../CONFIG/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

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

        public:
            static QSqlDatabase mDb;
            Converter ();
            Converter(const string& sentence);

            void          setString(const string& newstr);
            vector<Word>  getWords();
            ~Converter();
    };

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

    Converter::Converter()
    {
        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; }
    }

    Converter::Converter(const string &sentence) : Converter()
    {
        mSentence = sentence;
        extractTokens(); // extract tokens
    }


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

    void Converter::convertAllToLower()
    {
        for(Token& tok : mTokens)
            tok.alltolower ();
    }

    void Converter::setString(const string &newstr)
    {
        mTokens.clear ();
        mSentence = newstr;
        extractTokens ();
    }

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

        QSqlQuery       mLiteQr(this->mDb);
        string          qrStr = "SELECT DISTINCT wordtype FROM entries WHERE word = '" + wordname + "'";
        string          rawTypesCollections;

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

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

        if (rawTypesCollections.empty() && wordname.length() > 2 && recurDepth < 3) {
            return getWordTypes(wordname.substr(0, wordname.length() - 1), recurDepth + 1);
        } else if (rawTypesCollections.empty () && (recurDepth > 2 || wordname.length () <= 2)){
            set<WordType> nameEntity;
            nameEntity.insert (WordType::noun);
            return nameEntity;
        }

        set<string>     uniqueWT = getUnqStringWT (rawTypesCollections);

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

    set<string> Converter::getUnqStringWT(string& rawTypesCollections)
    {
        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

        set<string> uniqueWT;
        while (ss >> buf)
            uniqueWT.insert(buf);
        return uniqueWT;
    }

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

        vector<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 */