following latest API change
authorTasuku Suzuki <stasuku@gmail.com>
Wed, 22 Jan 2014 15:29:29 +0000 (00:29 +0900)
committerTasuku Suzuki <stasuku@gmail.com>
Wed, 22 Jan 2014 15:31:45 +0000 (00:31 +0900)
Change-Id: I40c3c3eadcdda5a213d692dad5adcde24fff99c5
Reviewed-on: http://cr.qtquick.me/796
Reviewed-by: Tasuku Suzuki <stasuku@gmail.com>
Tested-by: Tasuku Suzuki <stasuku@gmail.com>
examples/cpp/classifier/gender/widget.cpp
examples/qml/classifier/gender/gender.qml
src/imports/jubatus/main.cpp
src/jubatus/classifier/qjubatusclassifier.cpp
src/jubatus/classifier/qjubatusclassifier.h

index 4236107..260f6d4 100644 (file)
@@ -51,23 +51,25 @@ Widget::Widget(QWidget *parent)
     : QDialog(parent)
     , ui(new Ui::Widget)
 {
+    classifier.setTimeout(10.0);
+    classifier.setName(QStringLiteral("test"));
     ui->setupUi(this);
 
     connect(ui->male, &QPushButton::clicked, [&] {
-        classifier.train(QStringLiteral("test"), makeTrainData(QStringLiteral("male"), ui));
+        classifier.train(makeTrainData(QStringLiteral("male"), ui));
     });
 
     connect(ui->female, &QPushButton::clicked, [&] {
-        classifier.train(QStringLiteral("test"), makeTrainData(QStringLiteral("female"), ui));
+        classifier.train(makeTrainData(QStringLiteral("female"), ui));
     });
 
     connect(ui->other, &QPushButton::clicked, [&] {
-        classifier.train(QStringLiteral("test"), makeTrainData(QStringLiteral("other"), ui));
+        classifier.train(makeTrainData(QStringLiteral("other"), ui));
     });
 
     connect(ui->classify, &QPushButton::clicked, [&] {
         QStringList text;
-        QList<QList<QJubatusClassifier::EstimateResult>> results = classifier.classify(QStringLiteral("test"), QList<QVariantMap>() << makeDatum(ui));
+        QList<QList<QJubatusClassifier::EstimateResult>> results = classifier.classify(QList<QVariantMap>() << makeDatum(ui));
         foreach (const QList<QJubatusClassifier::EstimateResult> &result, results) {
             foreach (const QJubatusClassifier::EstimateResult &r, result) {
                 text.append(QString("%1\t%2").arg(r.label).arg(r.score));
index 5da9633..2f448ef 100644 (file)
@@ -141,5 +141,6 @@ Rectangle {
     Jubatus.Classifier {
         id: classifier
         name: 'test'
+        timeout: 10.0
     }
 }
index db2fe7c..0316fb6 100644 (file)
@@ -24,6 +24,7 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
+#include <QtCore/QDebug>
 #include <QtQml/QQmlExtensionPlugin>
 #include <QtQml/qqml.h>
 
 
 #include <jubatus/client.hpp>
 
-using std::make_pair;
-using std::pair;
-using std::string;
-using std::vector;
-using jubatus::classifier::datum;
-using jubatus::classifier::estimate_result;
-
 class QmlJubatusClassifier : public QJubatusClassifier
 {
     Q_OBJECT
-    Q_PROPERTY(QString name MEMBER m_name)
 public:
     QmlJubatusClassifier(QObject *parent = 0) : QJubatusClassifier(parent) {}
 
@@ -54,13 +47,11 @@ public:
     using QJubatusClassifier::classify;
     Q_INVOKABLE QVariantList classify(const QVariantList &data);
     Q_INVOKABLE QVariantList classify(const QVariantMap &data);
-
-    QString m_name;
 };
 
 void QmlJubatusClassifier::train(const QVariantList &data)
 {
-    vector<pair<string, datum>> train_data;
+    std::vector<jubatus::classifier::labeled_datum> train_data;
     foreach (const QVariant &v, data) {
         switch (v.type()) {
         case QVariant::List: {
@@ -68,7 +59,7 @@ void QmlJubatusClassifier::train(const QVariantList &data)
             if (!list.isEmpty()) {
                 QString name = list.takeFirst().toString();
                 foreach (const QVariant &v2, list) {
-                    train_data.push_back(make_pair(name.toStdString(), convert(v2.toMap())));
+                    train_data.push_back(jubatus::classifier::labeled_datum(name.toStdString(), convert(v2.toMap())));
                 }
             }
             break; }
@@ -77,31 +68,31 @@ void QmlJubatusClassifier::train(const QVariantList &data)
             break;
         }
     }
-    train(m_name.toStdString(), train_data);
+    train(train_data);
 }
 
 void QmlJubatusClassifier::train(const QString &label, const QVariantMap &data)
 {
-    vector<pair<string, datum>> train_data;
-    train_data.push_back(make_pair(label.toStdString(), convert(data)));
-    train(m_name.toStdString(), train_data);
+    std::vector<jubatus::classifier::labeled_datum> train_data;
+    train_data.push_back(jubatus::classifier::labeled_datum(label.toStdString(), convert(data)));
+    train(train_data);
 }
 
 QVariantList QmlJubatusClassifier::classify(const QVariantList &data)
 {
     QVariantList ret;
 
-    vector<datum> test_data;
+    std::vector<jubatus::client::common::datum> test_data;
     foreach (const QVariant &v, data) {
         test_data.push_back(convert(v.toMap()));
     }
 
-    vector<vector<estimate_result> > results = classify(m_name.toStdString(), test_data);
+    std::vector<std::vector<jubatus::classifier::estimate_result> > results = classify(test_data);
 
     for (size_t i = 0; i < results.size(); ++i) {
         QVariantList list;
         for (size_t j = 0; j < results[i].size(); ++j) {
-            const estimate_result& jr = results[i][j];
+            const jubatus::classifier::estimate_result& jr = results[i][j];
             QVariantMap qr;
             qr.insert(QStringLiteral("label"), QString::fromStdString(jr.label));
             qr.insert(QStringLiteral("score"), jr.score);
@@ -116,13 +107,13 @@ QVariantList QmlJubatusClassifier::classify(const QVariantMap &data)
 {
     QVariantList ret;
 
-    vector<datum> test_data;
+    std::vector<jubatus::client::common::datum> test_data;
     test_data.push_back(convert(data));
 
-    vector<vector<estimate_result> > results = classify(m_name.toStdString(), test_data);
+    std::vector<std::vector<jubatus::classifier::estimate_result> > results = classify(test_data);
 
     for (size_t i = 0; i < results[0].size(); ++i) {
-        const estimate_result& jr = results[0][i];
+        const jubatus::classifier::estimate_result& jr = results[0][i];
         QVariantMap qr;
         qr.insert(QStringLiteral("label"), QString::fromStdString(jr.label));
         qr.insert(QStringLiteral("score"), jr.score);
index 76d331b..c7c168e 100644 (file)
@@ -47,6 +47,7 @@ public:
 
     QString host;
     int port;
+    QString name;
     double timeout;
 };
 
@@ -55,6 +56,7 @@ QJubatusClassifier::Private::Private(QJubatusClassifier *parent)
     , client(0)
     , host(QStringLiteral("localhost"))
     , port(9199)
+    , name(QStringLiteral("classifier"))
     , timeout(1.0)
 {
 }
@@ -69,6 +71,11 @@ QJubatusClassifier::QJubatusClassifier(QObject *parent)
     , d(new Private(this))
 {
     connect(this, &QJubatusClassifier::destroyed, [this](){ delete d; });
+    auto deleteClient = [this]() { delete d->client; d->client = 0; };
+    connect(this, &QJubatusClassifier::hostChanged, deleteClient);
+    connect(this, &QJubatusClassifier::portChanged, deleteClient);
+    connect(this, &QJubatusClassifier::nameChanged, deleteClient);
+    connect(this, &QJubatusClassifier::timeoutChanged, deleteClient);
 }
 
 const QString &QJubatusClassifier::host() const
@@ -95,6 +102,18 @@ void QJubatusClassifier::setPort(int port)
     emit portChanged(port);
 }
 
+const QString &QJubatusClassifier::name() const
+{
+    return d->name;
+}
+
+void QJubatusClassifier::setName(const QString &name)
+{
+    if (d->name == name) return;
+    d->name = name;
+    emit nameChanged(name);
+}
+
 double QJubatusClassifier::timeout() const
 {
     return d->timeout;
@@ -107,9 +126,9 @@ void QJubatusClassifier::setTimeout(double timeout)
     emit timeoutChanged(timeout);
 }
 
-jubatus::classifier::datum QJubatusClassifier::convert(const QVariantMap &data)
+jubatus::client::common::datum QJubatusClassifier::convert(const QVariantMap &data)
 {
-    jubatus::classifier::datum ret;
+    jubatus::client::common::datum ret;
 
     foreach (const QString &key, data.keys()) {
         QVariant value = data.value(key);
@@ -132,31 +151,33 @@ jubatus::classifier::datum QJubatusClassifier::convert(const QVariantMap &data)
     return ret;
 }
 
-void QJubatusClassifier::train(const QString &name, const QList<QJubatusClassifier::TrainData> &data)
+void QJubatusClassifier::train(const QList<QJubatusClassifier::TrainData> &data)
 {
-    std::vector<std::pair<std::string, jubatus::classifier::datum>> train_data;
+    std::vector<jubatus::classifier::labeled_datum> train_data;
     foreach (const TrainData &v, data) {
-        train_data.push_back(make_pair(v.first.toStdString(), convert(v.second)));
+        train_data.push_back(jubatus::classifier::labeled_datum(v.first.toStdString(), convert(v.second)));
     }
-    train(name.toStdString(), train_data);
+    train(train_data);
 }
 
-void QJubatusClassifier::train(const std::string &name, const std::vector<std::pair<std::string, jubatus::classifier::datum>> &data)
+void QJubatusClassifier::train(const std::vector<jubatus::classifier::labeled_datum> &data)
 {
-    jubatus::classifier::client::classifier client(d->host.toStdString(), d->port, d->timeout);
-    client.train(name, data);
+    if (!d->client) {
+        d->client = new jubatus::classifier::client::classifier(d->host.toStdString(), d->port, d->name.toStdString(), d->timeout);
+    }
+    d->client->train(data);
 }
 
-QList<QList<QJubatusClassifier::EstimateResult>> QJubatusClassifier::classify(const QString &name, const QList<QVariantMap> &data)
+QList<QList<QJubatusClassifier::EstimateResult>> QJubatusClassifier::classify(const QList<QVariantMap> &data)
 {
     QList<QList<EstimateResult>> ret;
 
-    std::vector<jubatus::classifier::datum> test_data;
+    std::vector<jubatus::client::common::datum> test_data;
     foreach (const QVariant &v, data) {
         test_data.push_back(convert(v.toMap()));
     }
 
-    std::vector<std::vector<jubatus::classifier::estimate_result> > results = classify(name.toStdString(), test_data);
+    std::vector<std::vector<jubatus::classifier::estimate_result> > results = classify(test_data);
 
     for (size_t i = 0; i < results.size(); ++i) {
         QList<EstimateResult> list;
@@ -172,10 +193,12 @@ QList<QList<QJubatusClassifier::EstimateResult>> QJubatusClassifier::classify(co
     return ret;
 }
 
-std::vector<std::vector<jubatus::classifier::estimate_result>> QJubatusClassifier::classify(const std::string &name, const std::vector<jubatus::classifier::datum> &data)
+std::vector<std::vector<jubatus::classifier::estimate_result>> QJubatusClassifier::classify(const std::vector<jubatus::client::common::datum> &data)
 {
-    jubatus::classifier::client::classifier client(d->host.toStdString(), d->port, d->timeout);
-    return client.classify(name, data);
+    if (!d->client) {
+        d->client = new jubatus::classifier::client::classifier(d->host.toStdString(), d->port, d->name.toStdString(), d->timeout);
+    }
+    return d->client->classify(data);
 }
 
 
index 6e971ed..e131a21 100644 (file)
 #include "jubatus_global.h"
 
 namespace jubatus {
+    namespace client {
+        namespace common {
+            struct datum;
+        }
+    }
     namespace classifier {
-        struct datum;
         struct estimate_result;
+        struct labeled_datum;
     }
 }
 
@@ -44,12 +49,14 @@ class JUBATUS_EXPORT QJubatusClassifier : public QObject
     Q_OBJECT
     Q_PROPERTY(QString host READ host WRITE setHost NOTIFY hostChanged)
     Q_PROPERTY(int port READ port WRITE setPort NOTIFY portChanged)
+    Q_PROPERTY(QString name READ name WRITE setName NOTIFY nameChanged)
     Q_PROPERTY(double timeout READ timeout WRITE setTimeout NOTIFY timeoutChanged)
 public:
     explicit QJubatusClassifier(QObject *parent = 0);
 
     const QString &host() const;
     int port() const;
+    const QString &name() const;
     double timeout() const;
 
     struct EstimateResult {
@@ -59,23 +66,25 @@ public:
 
     typedef QPair<QString, QVariantMap> TrainData;
 
-    void train(const QString &name, const QList<QJubatusClassifier::TrainData> &data);
-    QList<QList<QJubatusClassifier::EstimateResult>> classify(const QString &name, const QList<QVariantMap> &data);
+    void train(const QList<QJubatusClassifier::TrainData> &data);
+    QList<QList<QJubatusClassifier::EstimateResult>> classify(const QList<QVariantMap> &data);
 
 public slots:
     void setHost(const QString &host);
     void setPort(int port);
+    void setName(const QString &name);
     void setTimeout(double timeout);
 
 signals:
     void hostChanged(const QString &host);
     void portChanged(int port);
+    void nameChanged(const QString &name);
     void timeoutChanged(double timeout);
 
 protected:
-    void train(const std::string &name, const std::vector<std::pair<std::string, jubatus::classifier::datum>> &data);
-    std::vector<std::vector<jubatus::classifier::estimate_result>> classify(const std::string &name, const std::vector<jubatus::classifier::datum> &data);
-    static jubatus::classifier::datum convert(const QVariantMap &data);
+    void train(const std::vector<jubatus::classifier::labeled_datum> &data);
+    std::vector<std::vector<jubatus::classifier::estimate_result>> classify(const std::vector<jubatus::client::common::datum> &data);
+    static jubatus::client::common::datum convert(const QVariantMap &data);
 
 private:
     class Private;