Removed convenience API

10 files changed, 25 insertions, 66 deletions

diff --git a/common/entitystorage.cpp b/common/entitystorage.cpp
index 22fd9e6..8a3391e 100644
--- a/common/entitystorage.cpp
+++ b/common/entitystorage.cpp
@@ -21,7 +21,7 @@
 
 static void scan(const Akonadi2::Storage::Transaction &transaction, const QByteArray &key, std::function<bool(const QByteArray &key, const Akonadi2::Entity &entity)> callback)
 {
-    transaction.scan(key, [=](const QByteArray &key, const QByteArray &value) -> bool {
+    transaction.openDatabase().scan(key, [=](const QByteArray &key, const QByteArray &value) -> bool {
         //Skip internals
         if (Akonadi2::Storage::isInternalKey(key)) {
             return true;
diff --git a/common/messagequeue.cpp b/common/messagequeue.cpp
index f8bcd46..8e3d7d7 100644
--- a/common/messagequeue.cpp
+++ b/common/messagequeue.cpp
@@ -76,7 +76,7 @@ void MessageQueue::enqueue(const QByteArray &value)
     }
     const qint64 revision = Akonadi2::Storage::maxRevision(mWriteTransaction) + 1;
     const QByteArray key = QString("%1").arg(revision).toUtf8();
-    mWriteTransaction.write(key, value);
+    mWriteTransaction.openDatabase().write(key, value);
     Akonadi2::Storage::setMaxRevision(mWriteTransaction, revision);
     if (implicitTransaction) {
         commit();
@@ -90,7 +90,7 @@ void MessageQueue::processRemovals()
     }
     auto transaction = std::move(mStorage.createTransaction(Akonadi2::Storage::ReadWrite));
     for (const auto &key : mPendingRemoval) {
-        transaction.remove(key);
+        transaction.openDatabase().remove(key);
     }
     transaction.commit();
     mPendingRemoval.clear();
@@ -117,7 +117,7 @@ KAsync::Job<void> MessageQueue::dequeueBatch(int maxBatchSize, const std::functi
     return KAsync::start<void>([this, maxBatchSize, resultHandler, resultCount](KAsync::Future<void> &future) {
         int count = 0;
         QList<KAsync::Future<void> > waitCondition;
-        mStorage.createTransaction(Akonadi2::Storage::ReadOnly).scan("", [this, resultHandler, resultCount, &count, maxBatchSize, &waitCondition](const QByteArray &key, const QByteArray &value) -> bool {
+        mStorage.createTransaction(Akonadi2::Storage::ReadOnly).openDatabase().scan("", [this, resultHandler, resultCount, &count, maxBatchSize, &waitCondition](const QByteArray &key, const QByteArray &value) -> bool {
             if (Akonadi2::Storage::isInternalKey(key) || mPendingRemoval.contains(key)) {
                 return true;
             }
diff --git a/common/pipeline.cpp b/common/pipeline.cpp
index c5e36ee..8ef6187 100644
--- a/common/pipeline.cpp
+++ b/common/pipeline.cpp
@@ -165,7 +165,7 @@ KAsync::Job<void> Pipeline::newEntity(void const *command, size_t size)
     flatbuffers::FlatBufferBuilder fbb;
     EntityBuffer::assembleEntityBuffer(fbb, metadataFbb.GetBufferPointer(), metadataFbb.GetSize(), entity->resource()->Data(), entity->resource()->size(), entity->local()->Data(), entity->local()->size());
 
-    d->transaction.write(key, QByteArray::fromRawData(reinterpret_cast<char const *>(fbb.GetBufferPointer()), fbb.GetSize()));
+    d->transaction.openDatabase().write(key, QByteArray::fromRawData(reinterpret_cast<char const *>(fbb.GetBufferPointer()), fbb.GetSize()));
     Akonadi2::Storage::setMaxRevision(d->transaction, newRevision);
     Log() << "Pipeline: wrote entity: " << key << newRevision;
 
@@ -220,7 +220,7 @@ KAsync::Job<void> Pipeline::modifiedEntity(void const *command, size_t size)
     auto diff = adaptorFactory->createAdaptor(*diffEntity);
 
     QSharedPointer<Akonadi2::ApplicationDomain::BufferAdaptor> current;
-    storage().createTransaction(Akonadi2::Storage::ReadOnly).scan(key, [&current, adaptorFactory](const QByteArray &key, const QByteArray &data) -> bool {
+    storage().createTransaction(Akonadi2::Storage::ReadOnly).openDatabase().scan(key, [&current, adaptorFactory](const QByteArray &key, const QByteArray &data) -> bool {
         Akonadi2::EntityBuffer buffer(const_cast<const char *>(data.data()), data.size());
         if (!buffer.isValid()) {
             Warning() << "Read invalid buffer from disk";
@@ -265,7 +265,7 @@ KAsync::Job<void> Pipeline::modifiedEntity(void const *command, size_t size)
     adaptorFactory->createBuffer(*newObject, fbb, metadataFbb.GetBufferPointer(), metadataFbb.GetSize());
 
     //TODO don't overwrite the old entry, but instead store a new revision
-    d->transaction.write(key, QByteArray::fromRawData(reinterpret_cast<char const *>(fbb.GetBufferPointer()), fbb.GetSize()));
+    d->transaction.openDatabase().write(key, QByteArray::fromRawData(reinterpret_cast<char const *>(fbb.GetBufferPointer()), fbb.GetSize()));
     Akonadi2::Storage::setMaxRevision(d->transaction, newRevision);
 
     return KAsync::start<void>([this, key, entityType, newRevision](KAsync::Future<void> &future) {
@@ -296,7 +296,7 @@ KAsync::Job<void> Pipeline::deletedEntity(void const *command, size_t size)
     const QByteArray key = QByteArray(reinterpret_cast<char const*>(deleteEntity->entityId()->Data()), deleteEntity->entityId()->size());
 
     //TODO instead of deleting the entry, a new revision should be created that marks the entity as deleted
-    d->transaction.remove(key);
+    d->transaction.openDatabase().remove(key);
     Akonadi2::Storage::setMaxRevision(d->transaction, newRevision);
     Log() << "Pipeline: deleted entity: "<< newRevision;
 
diff --git a/common/pipeline.h b/common/pipeline.h
index fee6a5e..a3b3735 100644
--- a/common/pipeline.h
+++ b/common/pipeline.h
@@ -142,7 +142,7 @@ public:
 
     void process(const PipelineState &state, Akonadi2::Storage::Transaction &transaction) Q_DECL_OVERRIDE
     {
-        transaction.scan(state.key(), [this, &state, &transaction](const QByteArray &key, const QByteArray &value) -> bool {
+        transaction.openDatabase().scan(state.key(), [this, &state, &transaction](const QByteArray &key, const QByteArray &value) -> bool {
             auto entity = Akonadi2::GetEntity(value);
             mFunction(state, *entity, transaction);
             processingCompleted(state);
diff --git a/common/storage.h b/common/storage.h
index 8a2e51f..191f535 100644
--- a/common/storage.h
+++ b/common/storage.h
@@ -130,13 +130,6 @@ public:
             return (d != nullptr);
         }
 
-        bool write(const QByteArray &key, const QByteArray &value, const std::function<void(const Storage::Error &error)> &errorHandler = std::function<void(const Storage::Error &error)>());
-
-        void remove(const QByteArray &key,
-                    const std::function<void(const Storage::Error &error)> &errorHandler = std::function<void(const Storage::Error &error)>());
-        int scan(const QByteArray &k,
-                    const std::function<bool(const QByteArray &key, const QByteArray &value)> &resultHandler,
-                    const std::function<void(const Storage::Error &error)> &errorHandler = std::function<void(const Storage::Error &error)>()) const;
     private:
         Transaction(Transaction& other);
         Transaction& operator=(Transaction& other);
diff --git a/common/storage_common.cpp b/common/storage_common.cpp
index 4de585d..a506cf8 100644
--- a/common/storage_common.cpp
+++ b/common/storage_common.cpp
@@ -62,7 +62,7 @@ void Storage::setMaxRevision(qint64 revision)
 
 void Storage::setMaxRevision(Akonadi2::Storage::Transaction &transaction, qint64 revision)
 {
-    transaction.write("__internal_maxRevision", QByteArray::number(revision));
+    transaction.openDatabase().write("__internal_maxRevision", QByteArray::number(revision));
 }
 
 qint64 Storage::maxRevision()
@@ -74,7 +74,7 @@ qint64 Storage::maxRevision()
 qint64 Storage::maxRevision(const Akonadi2::Storage::Transaction &transaction)
 {
     qint64 r = 0;
-    transaction.scan("__internal_maxRevision", [&](const QByteArray &, const QByteArray &revision) -> bool {
+    transaction.openDatabase().scan("__internal_maxRevision", [&](const QByteArray &, const QByteArray &revision) -> bool {
         r = revision.toLongLong();
         return false;
     }, [](const Error &error){
diff --git a/common/storage_lmdb.cpp b/common/storage_lmdb.cpp
index 7fed830..a048a71 100644
--- a/common/storage_lmdb.cpp
+++ b/common/storage_lmdb.cpp
@@ -337,40 +337,6 @@ Storage::NamedDatabase Storage::Transaction::openDatabase(const QByteArray &db,
     return Storage::NamedDatabase(p);
 }
 
-bool Storage::Transaction::write(const QByteArray &key, const QByteArray &value, const std::function<void(const Storage::Error &error)> &errorHandler)
-{
-    auto eHandler = [this, errorHandler](const Storage::Error &error) {
-        d->error = true;
-        errorHandler ? errorHandler(error) : d->defaultErrorHandler(error);
-    };
-    openDatabase("default", eHandler).write(key, value, eHandler);
-    d->implicitCommit = true;
-
-    return !d->error;
-}
-
-void Storage::Transaction::remove(const QByteArray &k,
-                     const std::function<void(const Storage::Error &error)> &errorHandler)
-{
-    auto eHandler = [this, errorHandler](const Storage::Error &error) {
-        d->error = true;
-        errorHandler ? errorHandler(error) : d->defaultErrorHandler(error);
-    };
-    openDatabase("default", eHandler).remove(k, eHandler);
-    d->implicitCommit = true;
-}
-
-int Storage::Transaction::scan(const QByteArray &k,
-                  const std::function<bool(const QByteArray &key, const QByteArray &value)> &resultHandler,
-                  const std::function<void(const Storage::Error &error)> &errorHandler) const
-{
-    auto db = openDatabase("default", std::function<void(const Storage::Error &error)>());
-    if (db) {
-        return db.scan(k, resultHandler, errorHandler);
-    }
-    return 0;
-}
-
 
 
 
diff --git a/tests/hawd/dataset.cpp b/tests/hawd/dataset.cpp
index 96479e0..e1cc3a4 100644
--- a/tests/hawd/dataset.cpp
+++ b/tests/hawd/dataset.cpp
@@ -237,7 +237,7 @@ qint64 Dataset::insertRow(const Row &row)
     }
 
     qint64 key = row.key();
-    m_transaction.write(QByteArray::fromRawData((const char *)&key, sizeof(qint64)), row.toBinary());
+    m_transaction.openDatabase().write(QByteArray::fromRawData((const char *)&key, sizeof(qint64)), row.toBinary());
     return key;
 }
 
@@ -253,7 +253,7 @@ void Dataset::eachRow(const std::function<void(const Row &row)> &resultHandler)
     }
 
     Row row(*this);
-    m_transaction.scan("",
+    m_transaction.openDatabase().scan("",
                    [&](const QByteArray &key, const QByteArray &value) -> bool {
                        if (key.size() != sizeof(qint64)) {
                            return true;
@@ -276,7 +276,7 @@ Dataset::Row Dataset::row(qint64 key)
     }
 
     Row row(*this, key);
-    m_transaction.scan(QByteArray::fromRawData((const char *)&key, sizeof(qint64)),
+    m_transaction.openDatabase().scan(QByteArray::fromRawData((const char *)&key, sizeof(qint64)),
             [&row](const QByteArray &key, const QByteArray &value) -> bool {
                 row.fromBinary(value);
                 return true;
diff --git a/tests/storagebenchmark.cpp b/tests/storagebenchmark.cpp
index f143c4d..e6ab049 100644
--- a/tests/storagebenchmark.cpp
+++ b/tests/storagebenchmark.cpp
@@ -98,7 +98,7 @@ private Q_SLOTS:
             if (store) {
                 auto transaction = store->createTransaction(Akonadi2::Storage::ReadWrite);
                 for (int i = 0; i < count; i++) {
-                    transaction.write(keyPrefix + QByteArray::number(i), event);
+                    transaction.openDatabase().write(keyPrefix + QByteArray::number(i), event);
                     if ((i % 10000) == 0) {
                         transaction.commit();
                         transaction = store->createTransaction(Akonadi2::Storage::ReadWrite);
@@ -149,7 +149,7 @@ private Q_SLOTS:
 
         QBENCHMARK {
             int hit = 0;
-            store->createTransaction(Akonadi2::Storage::ReadOnly).scan("", [&](const QByteArray &key, const QByteArray &value) -> bool {
+            store->createTransaction(Akonadi2::Storage::ReadOnly).openDatabase().scan("", [&](const QByteArray &key, const QByteArray &value) -> bool {
                 if (key == "key10000") {
                     //qDebug() << "hit";
                     hit++;
@@ -166,7 +166,7 @@ private Q_SLOTS:
 
         QBENCHMARK {
             int hit = 0;
-            store->createTransaction(Akonadi2::Storage::ReadOnly).scan("key40000", [&](const QByteArray &key, const QByteArray &value) -> bool {
+            store->createTransaction(Akonadi2::Storage::ReadOnly).openDatabase().scan("key40000", [&](const QByteArray &key, const QByteArray &value) -> bool {
                 hit++;
                 return true;
             });
diff --git a/tests/storagetest.cpp b/tests/storagetest.cpp
index 2e69634..7060ef2 100644
--- a/tests/storagetest.cpp
+++ b/tests/storagetest.cpp
@@ -29,7 +29,7 @@ private:
                     transaction = std::move(storage.createTransaction(Akonadi2::Storage::ReadWrite));
                 }
             }
-            transaction.write(keyPrefix + QByteArray::number(i), keyPrefix + QByteArray::number(i));
+            transaction.openDatabase().write(keyPrefix + QByteArray::number(i), keyPrefix + QByteArray::number(i));
         }
         transaction.commit();
     }
@@ -39,7 +39,7 @@ private:
         bool success = true;
         bool keyMatch = true;
         const auto reference = keyPrefix + QByteArray::number(i);
-        storage.createTransaction(Akonadi2::Storage::ReadOnly).scan(keyPrefix + QByteArray::number(i),
+        storage.createTransaction(Akonadi2::Storage::ReadOnly).openDatabase().scan(keyPrefix + QByteArray::number(i),
             [&keyMatch, &reference](const QByteArray &key, const QByteArray &value) -> bool {
                 if (value != reference) {
                     qDebug() << "Mismatch while reading";
@@ -103,7 +103,7 @@ private Q_SLOTS:
         {
             int hit = 0;
             Akonadi2::Storage store(testDataPath, dbName);
-            store.createTransaction(Akonadi2::Storage::ReadOnly).scan("", [&](const QByteArray &key, const QByteArray &value) -> bool {
+            store.createTransaction(Akonadi2::Storage::ReadOnly).openDatabase().scan("", [&](const QByteArray &key, const QByteArray &value) -> bool {
                 if (key == "key50") {
                     hit++;
                 }
@@ -117,7 +117,7 @@ private Q_SLOTS:
             int hit = 0;
             bool foundInvalidValue = false;
             Akonadi2::Storage store(testDataPath, dbName);
-            store.createTransaction(Akonadi2::Storage::ReadOnly).scan("key50", [&](const QByteArray &key, const QByteArray &value) -> bool {
+            store.createTransaction(Akonadi2::Storage::ReadOnly).openDatabase().scan("key50", [&](const QByteArray &key, const QByteArray &value) -> bool {
                 if (key != "key50") {
                     foundInvalidValue = true;
                 }
@@ -134,8 +134,8 @@ private Q_SLOTS:
         populate(3);
         Akonadi2::Storage store(testDataPath, dbName, Akonadi2::Storage::ReadWrite);
         auto transaction = store.createTransaction(Akonadi2::Storage::ReadWrite);
-        transaction.scan("key1", [&](const QByteArray &key, const QByteArray &value) -> bool {
-            transaction.remove(key, [](const Akonadi2::Storage::Error &) {
+        transaction.openDatabase().scan("key1", [&](const QByteArray &key, const QByteArray &value) -> bool {
+            transaction.openDatabase().remove(key, [](const Akonadi2::Storage::Error &) {
                 QVERIFY(false);
             });
             return false;
@@ -146,8 +146,8 @@ private Q_SLOTS:
     {
         populate(3);
         Akonadi2::Storage store(testDataPath, dbName, Akonadi2::Storage::ReadWrite);
-        store.createTransaction(Akonadi2::Storage::ReadOnly).scan("key1", [&](const QByteArray &key, const QByteArray &value) -> bool {
-            store.createTransaction(Akonadi2::Storage::ReadWrite).remove(key, [](const Akonadi2::Storage::Error &) {
+        store.createTransaction(Akonadi2::Storage::ReadOnly).openDatabase().scan("key1", [&](const QByteArray &key, const QByteArray &value) -> bool {
+            store.createTransaction(Akonadi2::Storage::ReadWrite).openDatabase().remove(key, [](const Akonadi2::Storage::Error &) {
                 QVERIFY(false);
             });
             return false;