VOCE multiple definition error

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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92

#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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194

#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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

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


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

    return a.exec();
}

Last edited on
Topic archived. No new replies allowed.