qt, cpp: Enable dll build for windows
[gpgme.git] / lang / qt / src / qgpgmedecryptjob.cpp
index 9ce4181..449e9aa 100644 (file)
@@ -5,12 +5,12 @@
     Copyright (c) 2004,2008 Klarälvdalens Datakonsult AB
     Copyright (c) 2016 Intevation GmbH
 
-    Libkleopatra is free software; you can redistribute it and/or
+    QGpgME is free software; you can redistribute it and/or
     modify it under the terms of the GNU General Public License as
     published by the Free Software Foundation; either version 2 of the
     License, or (at your option) any later version.
 
-    Libkleopatra is distributed in the hope that it will be useful,
+    QGpgME is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     General Public License for more details.
     your version.
 */
 
+#ifdef HAVE_CONFIG_H
+ #include "config.h"
+#endif
+
 #include "qgpgmedecryptjob.h"
 
 #include "dataprovider.h"
 
 #include <QBuffer>
 
-#include <boost/weak_ptr.hpp>
-
 #include <cassert>
 
 using namespace QGpgME;
 using namespace GpgME;
-using namespace boost;
 
 QGpgMEDecryptJob::QGpgMEDecryptJob(Context *context)
     : mixin_type(context)
@@ -57,11 +58,13 @@ QGpgMEDecryptJob::QGpgMEDecryptJob(Context *context)
 
 QGpgMEDecryptJob::~QGpgMEDecryptJob() {}
 
-static QGpgMEDecryptJob::result_type decrypt(Context *ctx, QThread *thread, const weak_ptr<QIODevice> &cipherText_, const weak_ptr<QIODevice> &plainText_)
+static QGpgMEDecryptJob::result_type decrypt(Context *ctx, QThread *thread,
+                                             const std::weak_ptr<QIODevice> &cipherText_,
+                                             const std::weak_ptr<QIODevice> &plainText_)
 {
 
-    const shared_ptr<QIODevice> cipherText = cipherText_.lock();
-    const shared_ptr<QIODevice> plainText = plainText_.lock();
+    const std::shared_ptr<QIODevice> cipherText = cipherText_.lock();
+    const std::shared_ptr<QIODevice> plainText = plainText_.lock();
 
     const _detail::ToThreadMover ctMover(cipherText, thread);
     const _detail::ToThreadMover ptMover(plainText,  thread);
@@ -76,7 +79,7 @@ static QGpgMEDecryptJob::result_type decrypt(Context *ctx, QThread *thread, cons
         const DecryptionResult res = ctx->decrypt(indata, outdata);
         Error ae;
         const QString log = _detail::audit_log_as_html(ctx, ae);
-        return make_tuple(res, out.data(), log, ae);
+        return std::make_tuple(res, out.data(), log, ae);
     } else {
         QGpgME::QIODeviceDataProvider out(plainText);
         Data outdata(&out);
@@ -84,37 +87,37 @@ static QGpgMEDecryptJob::result_type decrypt(Context *ctx, QThread *thread, cons
         const DecryptionResult res = ctx->decrypt(indata, outdata);
         Error ae;
         const QString log = _detail::audit_log_as_html(ctx, ae);
-        return make_tuple(res, QByteArray(), log, ae);
+        return std::make_tuple(res, QByteArray(), log, ae);
     }
 
 }
 
 static QGpgMEDecryptJob::result_type decrypt_qba(Context *ctx, const QByteArray &cipherText)
 {
-    const shared_ptr<QBuffer> buffer(new QBuffer);
+    const std::shared_ptr<QBuffer> buffer(new QBuffer);
     buffer->setData(cipherText);
     if (!buffer->open(QIODevice::ReadOnly)) {
         assert(!"This should never happen: QBuffer::open() failed");
     }
-    return decrypt(ctx, 0, buffer, shared_ptr<QIODevice>());
+    return decrypt(ctx, 0, buffer, std::shared_ptr<QIODevice>());
 }
 
 Error QGpgMEDecryptJob::start(const QByteArray &cipherText)
 {
-    run(bind(&decrypt_qba, _1, cipherText));
+    run(std::bind(&decrypt_qba, std::placeholders::_1, cipherText));
     return Error();
 }
 
-void QGpgMEDecryptJob::start(const shared_ptr<QIODevice> &cipherText, const shared_ptr<QIODevice> &plainText)
+void QGpgMEDecryptJob::start(const std::shared_ptr<QIODevice> &cipherText, const std::shared_ptr<QIODevice> &plainText)
 {
-    run(bind(&decrypt, _1, _2, _3, _4), cipherText, plainText);
+    run(std::bind(&decrypt, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4), cipherText, plainText);
 }
 
 GpgME::DecryptionResult QGpgME::QGpgMEDecryptJob::exec(const QByteArray &cipherText,
         QByteArray &plainText)
 {
     const result_type r = decrypt_qba(context(), cipherText);
-    plainText = get<1>(r);
+    plainText = std::get<1>(r);
     resultHook(r);
     return mResult;
 }
@@ -123,7 +126,7 @@ GpgME::DecryptionResult QGpgME::QGpgMEDecryptJob::exec(const QByteArray &cipherT
 
 void QGpgMEDecryptJob::resultHook(const result_type &tuple)
 {
-    mResult = get<0>(tuple);
+    mResult = std::get<0>(tuple);
 }
 
 #include "qgpgmedecryptjob.moc"