From 3062983d075761c457249b8c3c1248aa0d45e46a Mon Sep 17 00:00:00 2001
From: Christian Mollekopf <chrigi_1@fastmail.fm>
Date: Thu, 9 Apr 2015 14:00:26 +0200
Subject: Use QByteArray instead of QString

All identifiers should be latin1 and we make this explicit by using
QByteArray. QString is reserved for strings that can be UTF-8 or alike.
---
 client/main.cpp                 |  2 +-
 common/clientapi.cpp            |  6 ++--
 common/clientapi.h              | 66 ++++++++++++++++++++---------------------
 common/domainadaptor.h          | 10 +++----
 common/resourceaccess.cpp       | 10 +++----
 common/resourceaccess.h         |  4 +--
 dummyresource/domainadaptor.cpp |  8 ++---
 dummyresource/facade.cpp        |  2 +-
 synchronizer/listener.cpp       | 12 ++++----
 synchronizer/listener.h         |  4 +--
 tests/domainadaptortest.cpp     |  4 +--
 11 files changed, 64 insertions(+), 64 deletions(-)

diff --git a/client/main.cpp b/client/main.cpp
index 61c1c1a..b4cb081 100644
--- a/client/main.cpp
+++ b/client/main.cpp
@@ -41,7 +41,7 @@ int main(int argc, char *argv[])
     }
 
     for (const QString &resource: resources) {
-        Akonadi2::ResourceAccess *resAccess = new Akonadi2::ResourceAccess(resource);
+        Akonadi2::ResourceAccess *resAccess = new Akonadi2::ResourceAccess(resource.toLatin1());
         QObject::connect(&app, &QCoreApplication::aboutToQuit,
                         resAccess, &Akonadi2::ResourceAccess::close);
         resAccess->sendCommand(Akonadi2::Commands::SynchronizeCommand);
diff --git a/common/clientapi.cpp b/common/clientapi.cpp
index 6f0b421..0281b79 100644
--- a/common/clientapi.cpp
+++ b/common/clientapi.cpp
@@ -18,20 +18,20 @@ namespace Domain
 {
 
 template<>
-QString getTypeName<Event>()
+QByteArray getTypeName<Event>()
 {
     return "event";
 }
 
 template<>
-QString getTypeName<Todo>()
+QByteArray getTypeName<Todo>()
 {
     return "todo";
 }
 
 } // namespace Domain
 
-void Store::shutdown(const QString &identifier)
+void Store::shutdown(const QByteArray &identifier)
 {
     Akonadi2::ResourceAccess resourceAccess(identifier);
     //FIXME this starts the resource, just to shut it down again if it's not running in the first place.
diff --git a/common/clientapi.h b/common/clientapi.h
index 0ee934c..37fb185 100644
--- a/common/clientapi.h
+++ b/common/clientapi.h
@@ -180,9 +180,9 @@ namespace Domain {
 class BufferAdaptor {
 public:
     virtual ~BufferAdaptor() {}
-    virtual QVariant getProperty(const QString &key) const { return QVariant(); }
-    virtual void setProperty(const QString &key, const QVariant &value) {}
-    virtual QStringList availableProperties() const { return QStringList(); }
+    virtual QVariant getProperty(const QByteArray &key) const { return QVariant(); }
+    virtual void setProperty(const QByteArray &key, const QVariant &value) {}
+    virtual QList<QByteArray> availableProperties() const { return QList<QByteArray>(); }
 };
 
 class MemoryBufferAdaptor : public BufferAdaptor {
@@ -202,12 +202,12 @@ public:
 
     virtual ~MemoryBufferAdaptor() {}
 
-    virtual QVariant getProperty(const QString &key) const { return mValues.value(key); }
-    virtual void setProperty(const QString &key, const QVariant &value) { mValues.insert(key, value); }
-    virtual QStringList availableProperties() const { return mValues.keys(); }
+    virtual QVariant getProperty(const QByteArray &key) const { return mValues.value(key); }
+    virtual void setProperty(const QByteArray &key, const QVariant &value) { mValues.insert(key, value); }
+    virtual QByteArrayList availableProperties() const { return mValues.keys(); }
 
 private:
-    QHash<QString, QVariant> mValues;
+    QHash<QByteArray, QVariant> mValues;
 };
 
 /**
@@ -222,7 +222,7 @@ public:
     {
 
     }
-    AkonadiDomainType(const QString &resourceName, const QString &identifier, qint64 revision, const QSharedPointer<BufferAdaptor> &adaptor)
+    AkonadiDomainType(const QByteArray &resourceName, const QByteArray &identifier, qint64 revision, const QSharedPointer<BufferAdaptor> &adaptor)
         : mAdaptor(adaptor),
         mResourceName(resourceName),
         mIdentifier(identifier),
@@ -232,17 +232,17 @@ public:
 
     virtual ~AkonadiDomainType() {}
 
-    virtual QVariant getProperty(const QString &key) const { return mAdaptor->getProperty(key); }
-    virtual void setProperty(const QString &key, const QVariant &value){ mChangeSet.insert(key, value); mAdaptor->setProperty(key, value); }
+    virtual QVariant getProperty(const QByteArray &key) const { return mAdaptor->getProperty(key); }
+    virtual void setProperty(const QByteArray &key, const QVariant &value){ mChangeSet.insert(key, value); mAdaptor->setProperty(key, value); }
 
 private:
     QSharedPointer<BufferAdaptor> mAdaptor;
-    QHash<QString, QVariant> mChangeSet;
+    QHash<QByteArray, QVariant> mChangeSet;
     /*
      * Each domain object needs to store the resource, identifier, revision triple so we can link back to the storage location.
      */
     QString mResourceName;
-    QString mIdentifier;
+    QByteArray mIdentifier;
     qint64 mRevision;
 };
 
@@ -274,13 +274,13 @@ class Folder : public AkonadiDomainType {
  */
 
 template<class DomainType>
-QString getTypeName();
+QByteArray getTypeName();
 
 template<>
-QString getTypeName<Event>();
+QByteArray getTypeName<Event>();
 
 template<>
-QString getTypeName<Todo>();
+QByteArray getTypeName<Todo>();
 
 }
 
@@ -307,13 +307,13 @@ class Query
 public:
     Query() : syncOnDemand(true), processAll(false) {}
     //Could also be a propertyFilter
-    QStringList resources;
+    QByteArrayList resources;
     //Could also be a propertyFilter
-    QStringList ids;
+    QByteArrayList ids;
     //Filters to apply
-    QHash<QString, QVariant> propertyFilter;
+    QHash<QByteArray, QVariant> propertyFilter;
     //Properties to retrieve
-    QSet<QString> requestedProperties;
+    QSet<QByteArray> requestedProperties;
     bool syncOnDemand;
     bool processAll;
 };
@@ -331,7 +331,7 @@ template<class DomainType>
 class StoreFacade {
 public:
     virtual ~StoreFacade(){};
-    QString type() const { return Domain::getTypeName<DomainType>(); }
+    QByteArray type() const { return Domain::getTypeName<DomainType>(); }
     virtual Async::Job<void> create(const DomainType &domainObject) = 0;
     virtual Async::Job<void> modify(const DomainType &domainObject) = 0;
     virtual Async::Job<void> remove(const DomainType &domainObject) = 0;
@@ -354,15 +354,15 @@ public:
         return factory;
     }
 
-    static QString key(const QString &resource, const QString &type)
+    static QByteArray key(const QByteArray &resource, const QByteArray &type)
     {
         return resource + type;
     }
 
     template<class DomainType, class Facade>
-    void registerFacade(const QString &resource)
+    void registerFacade(const QByteArray &resource)
     {
-        const QString typeName = Domain::getTypeName<DomainType>();
+        const QByteArray typeName = Domain::getTypeName<DomainType>();
         mFacadeRegistry.insert(key(resource, typeName), [](){ return new Facade; });
     }
 
@@ -376,16 +376,16 @@ public:
      * FIXME the factory function should really be returning QSharedPointer<void>, which doesn't work (std::shared_pointer<void> would though). That way i.e. a test could keep the object alive until it's done.
      */
     template<class DomainType, class Facade>
-    void registerFacade(const QString &resource, const std::function<void*(void)> &customFactoryFunction)
+    void registerFacade(const QByteArray &resource, const std::function<void*(void)> &customFactoryFunction)
     {
-        const QString typeName = Domain::getTypeName<DomainType>();
+        const QByteArray typeName = Domain::getTypeName<DomainType>();
         mFacadeRegistry.insert(key(resource, typeName), customFactoryFunction);
     }
 
     template<class DomainType>
-    QSharedPointer<StoreFacade<DomainType> > getFacade(const QString &resource)
+    QSharedPointer<StoreFacade<DomainType> > getFacade(const QByteArray &resource)
     {
-        const QString typeName = Domain::getTypeName<DomainType>();
+        const QByteArray typeName = Domain::getTypeName<DomainType>();
         auto factoryFunction = mFacadeRegistry.value(key(resource, typeName));
         if (factoryFunction) {
             return QSharedPointer<StoreFacade<DomainType> >(static_cast<StoreFacade<DomainType>* >(factoryFunction()));
@@ -395,7 +395,7 @@ public:
     }
 
 private:
-    QHash<QString, std::function<void*(void)> > mFacadeRegistry;
+    QHash<QByteArray, std::function<void*(void)> > mFacadeRegistry;
 };
 
 /**
@@ -424,7 +424,7 @@ public:
             // query tells us in which resources we're interested
             // TODO: queries to individual resources could be parallelized
             Async::Job<void> job = Async::null<void>();
-            for(const QString &resource : query.resources) {
+            for(const QByteArray &resource : query.resources) {
                 auto facade = FacadeFactory::instance().getFacade<DomainType>(resource);
                 //We have to bind an instance to the function callback. Since we use a shared pointer this keeps the result provider instance (and thus also the emitter) alive.
                 std::function<void(const typename DomainType::Ptr &)> addCallback = std::bind(&ResultProvider<typename DomainType::Ptr>::add, resultSet, std::placeholders::_1);
@@ -463,7 +463,7 @@ public:
      */
     //TODO return job that tracks progress until resource has stored the message in it's queue?
     template <class DomainType>
-    static void create(const DomainType &domainObject, const QString &resourceIdentifier) {
+    static void create(const DomainType &domainObject, const QByteArray &resourceIdentifier) {
         //Potentially move to separate thread as well
         auto facade = FacadeFactory::instance().getFacade<DomainType>(resourceIdentifier);
         auto job = facade->create(domainObject);
@@ -478,7 +478,7 @@ public:
      * This includes moving etc. since these are also simple settings on a property.
      */
     template <class DomainType>
-    static void modify(const DomainType &domainObject, const QString &resourceIdentifier) {
+    static void modify(const DomainType &domainObject, const QByteArray &resourceIdentifier) {
         //Potentially move to separate thread as well
         auto facade = FacadeFactory::instance().getFacade<DomainType>(resourceIdentifier);
         facade.modify(domainObject);
@@ -488,13 +488,13 @@ public:
      * Remove an entity.
      */
     template <class DomainType>
-    static void remove(const DomainType &domainObject, const QString &resourceIdentifier) {
+    static void remove(const DomainType &domainObject, const QByteArray &resourceIdentifier) {
         //Potentially move to separate thread as well
         auto facade = FacadeFactory::instance().getFacade<DomainType>(resourceIdentifier);
         facade.remove(domainObject);
     }
 
-    static void shutdown(const QString &resourceIdentifier);
+    static void shutdown(const QByteArray &resourceIdentifier);
 };
 
 }
diff --git a/common/domainadaptor.h b/common/domainadaptor.h
index e46e893..692c8c1 100644
--- a/common/domainadaptor.h
+++ b/common/domainadaptor.h
@@ -21,7 +21,7 @@
 
 #include "entity_generated.h"
 #include <QVariant>
-#include <QString>
+#include <QByteArray>
 #include <functional>
 #include "clientapi.h" //for domain parts
 
@@ -35,7 +35,7 @@ template<typename BufferType>
 class PropertyMapper
 {
 public:
-    void setProperty(const QString &key, const QVariant &value, BufferType *buffer)
+    void setProperty(const QByteArray &key, const QVariant &value, BufferType *buffer)
     {
         if (mWriteAccessors.contains(key)) {
             auto accessor = mWriteAccessors.value(key);
@@ -43,7 +43,7 @@ public:
         }
     }
 
-    virtual QVariant getProperty(const QString &key, BufferType const *buffer) const
+    virtual QVariant getProperty(const QByteArray &key, BufferType const *buffer) const
     {
         if (mReadAccessors.contains(key)) {
             auto accessor = mReadAccessors.value(key);
@@ -51,8 +51,8 @@ public:
         }
         return QVariant();
     }
-    QHash<QString, std::function<QVariant(BufferType const *)> > mReadAccessors;
-    QHash<QString, std::function<void(const QVariant &, BufferType*)> > mWriteAccessors;
+    QHash<QByteArray, std::function<QVariant(BufferType const *)> > mReadAccessors;
+    QHash<QByteArray, std::function<void(const QVariant &, BufferType*)> > mWriteAccessors;
 };
 
 //The factory should define how to go from an entitybuffer (local + resource buffer), to a domain type adapter.
diff --git a/common/resourceaccess.cpp b/common/resourceaccess.cpp
index 7320e50..7a343f9 100644
--- a/common/resourceaccess.cpp
+++ b/common/resourceaccess.cpp
@@ -64,8 +64,8 @@ public:
 class ResourceAccess::Private
 {
 public:
-    Private(const QString &name, ResourceAccess *ra);
-    QString resourceName;
+    Private(const QByteArray &name, ResourceAccess *ra);
+    QByteArray resourceName;
     QLocalSocket *socket;
     QTimer *tryOpenTimer;
     bool startingProcess;
@@ -77,7 +77,7 @@ public:
     uint messageId;
 };
 
-ResourceAccess::Private::Private(const QString &name, ResourceAccess *q)
+ResourceAccess::Private::Private(const QByteArray &name, ResourceAccess *q)
     : resourceName(name),
       socket(new QLocalSocket(q)),
       tryOpenTimer(new QTimer(q)),
@@ -87,7 +87,7 @@ ResourceAccess::Private::Private(const QString &name, ResourceAccess *q)
 {
 }
 
-ResourceAccess::ResourceAccess(const QString &resourceName, QObject *parent)
+ResourceAccess::ResourceAccess(const QByteArray &resourceName, QObject *parent)
     : QObject(parent),
       d(new Private(resourceName, this))
 {
@@ -112,7 +112,7 @@ ResourceAccess::~ResourceAccess()
 
 }
 
-QString ResourceAccess::resourceName() const
+QByteArray ResourceAccess::resourceName() const
 {
     return d->resourceName;
 }
diff --git a/common/resourceaccess.h b/common/resourceaccess.h
index a5a2547..088bf36 100644
--- a/common/resourceaccess.h
+++ b/common/resourceaccess.h
@@ -35,10 +35,10 @@ class ResourceAccess : public QObject
     Q_OBJECT
 
 public:
-    ResourceAccess(const QString &resourceName, QObject *parent = 0);
+    ResourceAccess(const QByteArray &resourceName, QObject *parent = 0);
     ~ResourceAccess();
 
-    QString resourceName() const;
+    QByteArray resourceName() const;
     bool isReady() const;
 
     Async::Job<void> sendCommand(int commandId);
diff --git a/dummyresource/domainadaptor.cpp b/dummyresource/domainadaptor.cpp
index 2182f9a..7a767ca 100644
--- a/dummyresource/domainadaptor.cpp
+++ b/dummyresource/domainadaptor.cpp
@@ -27,7 +27,7 @@ public:
 
     }
 
-    void setProperty(const QString &key, const QVariant &value)
+    void setProperty(const QByteArray &key, const QVariant &value)
     {
         if (mResourceMapper && mResourceMapper->mWriteAccessors.contains(key)) {
             // mResourceMapper->setProperty(key, value, mResourceBuffer);
@@ -36,7 +36,7 @@ public:
         }
     }
 
-    virtual QVariant getProperty(const QString &key) const
+    virtual QVariant getProperty(const QByteArray &key) const
     {
         if (mResourceBuffer && mResourceMapper->mReadAccessors.contains(key)) {
             return mResourceMapper->getProperty(key, mResourceBuffer);
@@ -47,9 +47,9 @@ public:
         return QVariant();
     }
 
-    virtual QStringList availableProperties() const
+    virtual QList<QByteArray> availableProperties() const
     {
-        QStringList props;
+        QList<QByteArray> props;
         props << mResourceMapper->mReadAccessors.keys();
         props << mLocalMapper->mReadAccessors.keys();
         return props;
diff --git a/dummyresource/facade.cpp b/dummyresource/facade.cpp
index d196e54..1af735e 100644
--- a/dummyresource/facade.cpp
+++ b/dummyresource/facade.cpp
@@ -184,7 +184,7 @@ void DummyResourceFacade::readValue(QSharedPointer<Akonadi2::Storage> storage, c
             auto adaptor = mFactory->createAdaptor(buffer.entity());
             //TODO only copy requested properties
             auto memoryAdaptor = QSharedPointer<Akonadi2::Domain::MemoryBufferAdaptor>::create(*adaptor);
-            auto event = QSharedPointer<Akonadi2::Domain::Event>::create("org.kde.dummy", QString::fromUtf8(static_cast<char*>(keyValue), keySize), revision, memoryAdaptor);
+            auto event = QSharedPointer<Akonadi2::Domain::Event>::create("org.kde.dummy", QByteArray::fromRawData(static_cast<char*>(keyValue), keySize), revision, memoryAdaptor);
             resultCallback(event);
         }
         return true;
diff --git a/synchronizer/listener.cpp b/synchronizer/listener.cpp
index edd9123..00d9207 100644
--- a/synchronizer/listener.cpp
+++ b/synchronizer/listener.cpp
@@ -35,7 +35,7 @@
 #include <QLocalSocket>
 #include <QTimer>
 
-Listener::Listener(const QString &resourceName, QObject *parent)
+Listener::Listener(const QByteArray &resourceName, QObject *parent)
     : QObject(parent),
       m_server(new QLocalServer(this)),
       m_resourceName(resourceName),
@@ -48,11 +48,11 @@ Listener::Listener(const QString &resourceName, QObject *parent)
             this, &Listener::refreshRevision);
     connect(m_server, &QLocalServer::newConnection,
              this, &Listener::acceptConnection);
-    Log() << QString("Trying to open %1").arg(resourceName);
-    if (!m_server->listen(resourceName)) {
+    Log() << "Trying to open " << m_resourceName;
+    if (!m_server->listen(QString::fromLatin1(resourceName))) {
         // FIXME: multiple starts need to be handled here
         m_server->removeServer(resourceName);
-        if (!m_server->listen(resourceName)) {
+        if (!m_server->listen(QString::fromLatin1(resourceName))) {
             Warning() << "Utter failure to start server";
             exit(-1);
         }
@@ -365,10 +365,10 @@ void Listener::loadResource()
         Log() << QString("Resource factory: %1").arg((qlonglong)resourceFactory);
         Log() << QString("\tResource: %1").arg((qlonglong)m_resource);
         //TODO: this doesn't really list all the facades .. fix
-        Log() << QString("\tFacades: %1").arg(Akonadi2::FacadeFactory::instance().getFacade<Akonadi2::Domain::Event>(m_resourceName)->type());
+        Log() << "\tFacades: " << Akonadi2::FacadeFactory::instance().getFacade<Akonadi2::Domain::Event>(m_resourceName)->type();
         m_resource->configurePipeline(m_pipeline);
     } else {
-        Error() << QString("Failed to load resource %1").arg(m_resourceName);
+        Error() << "Failed to load resource " << m_resourceName;
     }
     //TODO: on failure ... what?
     //Enter broken state?
diff --git a/synchronizer/listener.h b/synchronizer/listener.h
index 8dad3a4..d2ef0fc 100644
--- a/synchronizer/listener.h
+++ b/synchronizer/listener.h
@@ -58,7 +58,7 @@ class Listener : public QObject
     Q_OBJECT
 
 public:
-    Listener(const QString &resourceName, QObject *parent = 0);
+    Listener(const QByteArray &resourceName, QObject *parent = 0);
     ~Listener();
 
 Q_SIGNALS:
@@ -87,7 +87,7 @@ private:
     QLocalServer *m_server;
     QVector<Client> m_connections;
     flatbuffers::FlatBufferBuilder m_fbb;
-    const QString m_resourceName;
+    const QByteArray m_resourceName;
     Akonadi2::Resource *m_resource;
     Akonadi2::Pipeline *m_pipeline;
     QTimer *m_clientBufferProcessesTimer;
diff --git a/tests/domainadaptortest.cpp b/tests/domainadaptortest.cpp
index cedbf94..e45a9a3 100644
--- a/tests/domainadaptortest.cpp
+++ b/tests/domainadaptortest.cpp
@@ -21,7 +21,7 @@ public:
     {
     }
 
-    void setProperty(const QString &key, const QVariant &value)
+    void setProperty(const QByteArray &key, const QVariant &value)
     {
         if (mResourceMapper->mWriteAccessors.contains(key)) {
             // mResourceMapper.setProperty(key, value, mResourceBuffer);
@@ -30,7 +30,7 @@ public:
         }
     }
 
-    virtual QVariant getProperty(const QString &key) const
+    virtual QVariant getProperty(const QByteArray &key) const
     {
         if (mResourceBuffer && mResourceMapper->mReadAccessors.contains(key)) {
             return mResourceMapper->getProperty(key, mResourceBuffer);
-- 
cgit v1.2.3