VOCE multiple definition error

[Darven]

Hello,
I'm new here, and I tried using VOCE (http://voce.sourceforge.net/) to create a simple voice interface for basic tasks, on QtCreator (using Qt 5.7).

My problem is when trying to compile a prototype version of the code, I get the multiple definition error for most of the functions.
(example "D:\qt test project\voceTest\voce.h:76: erreur : multiple definition of `voce::internal::log(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)'")

I tried using the "internal" namespace of VOCE, and it was not recognized.


Here are my files :

mainwindow.h

#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QMainWindow>

#ifdef WIN32
#include <windows.h>
#else
#include <unistd.h>
#endif


#include <QObject>
#include <vector>
#include <voce.h>

class voceInterface : public QObject
{
    Q_OBJECT
signals:
    void signalGoToTab(int index);
    void signalSetText(QString text);
    void signalAddText(QString text);
    void signalSetOnline();
    void signalSetOffline();
    void signalSetQueue(int queue);
};

class voceCustom
{
public:
    voceCustom(voceInterface *Interface);
    ~voceCustom();

    std::vector<std::string> *Log;
    void clearLog();
    void addLog(std::string string);

    voceInterface *currentInterface;

    void start();
    void stop();
    std::string pop();
    std::string popAll();
    int getQueue();

    bool hasString(std::string string, int QueueLength = 0);
};

namespace Ui {
class MainWindow;
}

class MainWindow : public QMainWindow
{
    Q_OBJECT

public:
    explicit MainWindow(QWidget *parent = 0);
    ~MainWindow();

    voceCustom *currentVoce;
    voceInterface *currentVoceInterface;

    void goToTab(int index);
    void setText(QString text);
    QString getText();
    void addText(QString text);
    void setOnline();
    void setOffline();
    void setQueue(int queue);

private slots:
    void on_startButton_clicked();

    void on_stopButton_clicked();

public slots:

    void slotGoToTab(int index);
    void slotSetText(QString text);
    void slotAddText(QString text);
    void slotSetOnline();
    void slotSetOffline();
    void slotSetQueue(int queue);

private:
    Ui::MainWindow *ui;
};

#endif // MAINWINDOW_H 

mainwindow.cpp

#include "mainwindow.h"
#include "ui_mainwindow.h"


voceCustom::voceCustom(voceInterface *Interface)
{
    voce::init(".", false, true, "./grammar", "commandGrammar");
    Log = new std::vector<std::string>;
    currentInterface = Interface;
}

voceCustom::~voceCustom()
{
    voce::destroy();
    delete Log;
}

//-------------------

void voceCustom::clearLog()
{
    this->Log->clear();
}

void voceCustom::addLog(std::string string)
{
    std::vector<std::string>::iterator Iter;
    Iter = this->Log->begin();
    Iter = this->Log->insert(Iter, string);
}

//-------------------

void voceCustom::start()
{
    voce::setRecognizerEnabled(true);
    emit currentInterface->signalSetOnline();
}

void voceCustom::stop()
{
    voce::setRecognizerEnabled(false);
    emit currentInterface->signalSetOffline();
}

std::string voceCustom::pop()
{
    std::string string=voce::popRecognizedString();
    this->addLog(string);
    return string;
}

std::string voceCustom::popAll()
{
    std::string totalString = "";
    while (voce::getRecognizerQueueSize() > 0)
    {
        std::string newString = pop();
        totalString += "/n" + newString;
    }
    return totalString;
}

int voceCustom::getQueue()
{
    return voce::getRecognizerQueueSize();
}


bool voceCustom::hasString(std::string string, int QueueLength)
{
    bool result(false);
    if (this->Log->size()>0 && (QueueLength==0 || QueueLength>=(int)this->Log->size()))
    {
        for (int i=0;i<(int)this->Log->size();i++)
        {
            result = (result || (this->Log->at(i).rfind(string) != std::string::npos));
        }
    }
    else if (this->Log->size()>0)
    {
        for (int i=0;i<QueueLength;i++)
        {
            result = (result || (this->Log->at(i).rfind(string) != std::string::npos));
        }
    }
    return result;
}


MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindow)
{
    currentVoceInterface = new voceInterface();
    currentVoce = new voceCustom(currentVoceInterface);
    ui->setupUi(this);
    QObject::connect(currentVoceInterface,SIGNAL(signalGoToTab()),this,SLOT(slotGoToTab(int index)));
    QObject::connect(currentVoceInterface,SIGNAL(signalSetText()),this,SLOT(slotSetText(QString text)));
    QObject::connect(currentVoceInterface,SIGNAL(signalAddText()),this,SLOT(slotAddText(QString text)));
    QObject::connect(currentVoceInterface,SIGNAL(signalSetOnline()),this,SLOT(slotSetOnline(index)));
    QObject::connect(currentVoceInterface,SIGNAL(signalSetOffline()),this,SLOT(slotSetOffline(index)));
    QObject::connect(currentVoceInterface,SIGNAL(signalSetQueue()),this,SLOT(slotSetQueue(int queue)));
}

MainWindow::~MainWindow()
{
    delete currentVoce;
    delete currentVoceInterface;
    delete ui;
}

// Voce commands --------------------------------------------------------

void MainWindow::on_startButton_clicked()
{
    this->currentVoce->start();
}

void MainWindow::on_stopButton_clicked()
{
    this->currentVoce->stop();
}

void MainWindow::slotGoToTab(int index)
{
    goToTab(index);
}

void MainWindow::slotSetText(QString text)
{
    setText(text);
}

void MainWindow::slotAddText(QString text)
{
    addText(text);
}

void MainWindow::slotSetOnline()
{
    setOnline();
}

void MainWindow::slotSetOffline()
{
    setOffline();
}

void MainWindow::slotSetQueue(int queue)
{
    slotSetQueue(queue);
}


// Widget control ---------------------------------------------------------

void MainWindow::goToTab(int index)
{
    ui->tabWidget->setCurrentIndex(index);
}

void MainWindow::setText(QString text)
{
    ui->textEdit->setText(text);
}

QString MainWindow::getText()
{
    return ui->textEdit->toPlainText();
}

void MainWindow::addText(QString text)
{
    this->setText(this->getText() + text);
}

void MainWindow::setOnline()
{
    ui->lcdNumber->setSegmentStyle(QLCDNumber::Flat);
    ui->lcdNumber->display(00);
}

void MainWindow::setOffline()
{
    ui->lcdNumber->setSegmentStyle(QLCDNumber::Filled);
    ui->lcdNumber->display("OFF");
}

void MainWindow::setQueue(int queue)
{
    ui->lcdNumber->display(queue);
}

main.cpp

#include "mainwindow.h"
#include <QApplication>


int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    MainWindow w;
    w.show();

    return a.exec();
}