Generalized facade code.

A default implementation is now nothing but an empty shell.

1 files changed, 126 insertions, 2 deletions

diff --git a/common/facade.h b/common/facade.h
index d9ec0c9..e32ee96 100644
--- a/common/facade.h
+++ b/common/facade.h
@@ -31,6 +31,8 @@
 #include "domainadaptor.h"
 #include "entitybuffer.h"
 #include "log.h"
+#include "storage.h"
+#include "resultset.h"
 
 /**
  * A QueryRunner runs a query and updates the corresponding result set.
@@ -107,7 +109,8 @@ public:
     GenericFacade(const QByteArray &resourceIdentifier, const QSharedPointer<DomainTypeAdaptorFactoryInterface<DomainType> > &adaptorFactory = QSharedPointer<DomainTypeAdaptorFactoryInterface<DomainType> >())
         : Akonadi2::StoreFacade<DomainType>(),
         mResourceAccess(new ResourceAccess(resourceIdentifier)),
-        mDomainTypeAdaptorFactory(adaptorFactory)
+        mDomainTypeAdaptorFactory(adaptorFactory),
+        mResourceInstanceIdentifier(resourceIdentifier)
     {
     }
 
@@ -214,12 +217,133 @@ protected:
         return KAsync::null<void>();
     }
 
-    virtual KAsync::Job<qint64> load(const Akonadi2::Query &query, const QSharedPointer<Akonadi2::ResultProvider<Akonadi2::ApplicationDomain::Event::Ptr> > &resultProvider, qint64 oldRevision, qint64 newRevision) { return KAsync::null<qint64>(); };
+    static void scan(const QSharedPointer<Akonadi2::Storage> &storage, const QByteArray &key, std::function<bool(const QByteArray &key, const Akonadi2::Entity &entity)> callback)
+    {
+        storage->scan(key, [=](void *keyValue, int keySize, void *dataValue, int dataSize) -> bool {
+            //Skip internals
+            if (Akonadi2::Storage::isInternalKey(keyValue, keySize)) {
+                return true;
+            }
+
+            //Extract buffers
+            Akonadi2::EntityBuffer buffer(dataValue, dataSize);
+
+            //FIXME implement buffer.isValid()
+            // const auto resourceBuffer = Akonadi2::EntityBuffer::readBuffer<DummyEvent>(buffer.entity().resource());
+            // const auto localBuffer = Akonadi2::EntityBuffer::readBuffer<Akonadi2::ApplicationDomain::Buffer::Event>(buffer.entity().local());
+            // const auto metadataBuffer = Akonadi2::EntityBuffer::readBuffer<Akonadi2::Metadata>(buffer.entity().metadata());
+
+            // if ((!resourceBuffer && !localBuffer) || !metadataBuffer) {
+            //     qWarning() << "invalid buffer " << QByteArray::fromRawData(static_cast<char*>(keyValue), keySize);
+            //     return true;
+            // }
+            return callback(QByteArray::fromRawData(static_cast<char*>(keyValue), keySize), buffer.entity());
+        },
+        [](const Akonadi2::Storage::Error &error) {
+            qWarning() << "Error during query: " << error.message;
+        });
+    }
+
+    static void readValue(const QSharedPointer<Akonadi2::Storage> &storage, const QByteArray &key, const std::function<void(const typename DomainType::Ptr &)> &resultCallback, const QSharedPointer<DomainTypeAdaptorFactoryInterface<DomainType> > &adaptorFactory)
+    {
+        scan(storage, key, [=](const QByteArray &key, const Akonadi2::Entity &entity) {
+            const auto metadataBuffer = Akonadi2::EntityBuffer::readBuffer<Akonadi2::Metadata>(entity.metadata());
+            qint64 revision = metadataBuffer ? metadataBuffer->revision() : -1;
+            //This only works for a 1:1 mapping of resource to domain types.
+            //Not i.e. for tags that are stored as flags in each entity of an imap store.
+            //additional properties that don't have a 1:1 mapping (such as separately stored tags),
+            //could be added to the adaptor
+            auto domainObject = QSharedPointer<DomainType>::create("org.kde.dummy.instance1", key, revision, adaptorFactory->createAdaptor(entity));
+            resultCallback(domainObject);
+            return true;
+        });
+    }
+
+    static ResultSet fullScan(const QSharedPointer<Akonadi2::Storage> &storage)
+    {
+        //TODO use a result set with an iterator, to read values on demand
+        QVector<QByteArray> keys;
+        scan(storage, QByteArray(), [=, &keys](const QByteArray &key, const Akonadi2::Entity &) {
+            keys << key;
+            return true;
+        });
+        return ResultSet(keys);
+    }
+
+    static ResultSet filteredSet(const ResultSet &resultSet, const std::function<bool(const Akonadi2::ApplicationDomain::ApplicationDomainType::Ptr &domainObject)> &filter, const QSharedPointer<Akonadi2::Storage> &storage, const QSharedPointer<DomainTypeAdaptorFactoryInterface<DomainType> > &adaptorFactory)
+    {
+        auto resultSetPtr = QSharedPointer<ResultSet>::create(resultSet);
+
+        //Read through the source values and return whatever matches the filter
+        std::function<bool(std::function<void(const Akonadi2::ApplicationDomain::ApplicationDomainType::Ptr &)>)> generator = [resultSetPtr, storage, adaptorFactory, filter](std::function<void(const Akonadi2::ApplicationDomain::ApplicationDomainType::Ptr &)> callback) -> bool {
+            while (resultSetPtr->next()) {
+                readValue(storage, resultSetPtr->id(), [filter, callback](const Akonadi2::ApplicationDomain::ApplicationDomainType::Ptr &domainObject) {
+                    if (filter(domainObject)) {
+                        callback(domainObject);
+                    }
+                }, adaptorFactory);
+            }
+            return false;
+        };
+        return ResultSet(generator);
+    }
 
+    static ResultSet getResultSet(const Akonadi2::Query &query, const QSharedPointer<Akonadi2::Storage> &storage, const QSharedPointer<DomainTypeAdaptorFactoryInterface<DomainType> > &adaptorFactory, const QByteArray &resourceInstanceIdentifier)
+    {
+        QSet<QByteArray> appliedFilters;
+        ResultSet resultSet = Akonadi2::ApplicationDomain::TypeImplementation<DomainType>::queryIndexes(query, resourceInstanceIdentifier, appliedFilters);
+        const auto remainingFilters = query.propertyFilter.keys().toSet() - appliedFilters;
+
+        //We do a full scan if there were no indexes available to create the initial set.
+        if (appliedFilters.isEmpty()) {
+            resultSet = fullScan(storage);
+        }
+
+        auto filter = [remainingFilters, query](const Akonadi2::ApplicationDomain::ApplicationDomainType::Ptr &domainObject) -> bool {
+            for (const auto &filterProperty : remainingFilters) {
+                //TODO implement other comparison operators than equality
+                if (domainObject->getProperty(filterProperty) != query.propertyFilter.value(filterProperty)) {
+                    return false;
+                }
+            }
+            return true;
+        };
+
+        return filteredSet(resultSet, filter, storage, adaptorFactory);
+    }
+
+    virtual KAsync::Job<qint64> load(const Akonadi2::Query &query, const QSharedPointer<Akonadi2::ResultProvider<typename DomainType::Ptr> > &resultProvider, qint64 oldRevision, qint64 newRevision)
+    {
+        return KAsync::start<qint64>([=]() -> qint64 {
+            auto storage = QSharedPointer<Akonadi2::Storage>::create(Akonadi2::Store::storageLocation(), mResourceInstanceIdentifier);
+            storage->setDefaultErrorHandler([](const Akonadi2::Storage::Error &error) {
+                Warning() << "Error during query: " << error.store << error.message;
+            });
+
+            storage->startTransaction(Akonadi2::Storage::ReadOnly);
+            //TODO start transaction on indexes as well
+            const qint64 revision = storage->maxRevision();
+
+            auto resultSet = getResultSet(query, storage, mDomainTypeAdaptorFactory, mResourceInstanceIdentifier);
+
+            // TODO only emit changes and don't replace everything
+            resultProvider->clear();
+            auto resultCallback = std::bind(&Akonadi2::ResultProvider<typename DomainType::Ptr>::add, resultProvider, std::placeholders::_1);
+            while(resultSet.next([resultCallback](const Akonadi2::ApplicationDomain::ApplicationDomainType::Ptr &value) -> bool {
+                resultCallback(Akonadi2::ApplicationDomain::ApplicationDomainType::getInMemoryRepresentation<DomainType>(value));
+                return true;
+            })){};
+            storage->abortTransaction();
+            return revision;
+        });
+    }
+
+private:
 protected:
     //TODO use one resource access instance per application => make static
     QSharedPointer<Akonadi2::ResourceAccess> mResourceAccess;
     QSharedPointer<DomainTypeAdaptorFactoryInterface<DomainType> > mDomainTypeAdaptorFactory;
+    QByteArray mResourceInstanceIdentifier;
 };
 
 }