File indexing completed on 2024-05-12 05:26:27

 /*
  * Copyright (C) 2015 Christian Mollekopf <chrigi_1@fastmail.fm>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2.1 of the License, or (at your option) version 3, or any
  * later version accepted by the membership of KDE e.V. (or its
  * successor approved by the membership of KDE e.V.), which shall
  * act as a proxy defined in Section 6 of version 3 of the license.
  *
  * This library 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
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library.  If not, see <http://www.gnu.org/licenses/>.
  */
 #pragma once
 
 #include "sinktest_export.h"
 #include <KAsync/Async>
 
 #include <common/domainadaptor.h>
 #include <common/resultprovider.h>
 #include <common/resourceaccess.h>
 #include <common/facade.h>
 #include <common/genericresource.h>
 #include <common/commands.h>
 
 // Replace with something different
 #include "event_generated.h"
 #include "mail_generated.h"
 #include "createentity_generated.h"
 
 class SINKTEST_EXPORT TestEventAdaptorFactory : public DomainTypeAdaptorFactory<Sink::ApplicationDomain::Event>
 {
 public:
     TestEventAdaptorFactory() : DomainTypeAdaptorFactory()
     {
     }
 
     virtual ~TestEventAdaptorFactory(){};
 };
 
 class SINKTEST_EXPORT TestMailAdaptorFactory : public DomainTypeAdaptorFactory<Sink::ApplicationDomain::Mail>
 {
 public:
     TestMailAdaptorFactory() : DomainTypeAdaptorFactory()
     {
     }
 
     virtual ~TestMailAdaptorFactory(){};
 };
 
 class SINKTEST_EXPORT TestResourceAccess : public Sink::ResourceAccessInterface
 {
     Q_OBJECT
 public:
     virtual ~TestResourceAccess(){};
     KAsync::Job<void> sendCommand(int commandId) Q_DECL_OVERRIDE
     {
         return KAsync::null<void>();
     }
     KAsync::Job<void> sendCommand(int commandId, flatbuffers::FlatBufferBuilder &fbb) Q_DECL_OVERRIDE
     {
         return KAsync::null<void>();
     }
     KAsync::Job<void> synchronizeResource(const Sink::QueryBase &) Q_DECL_OVERRIDE
     {
         return KAsync::null<void>();
     }
 
     void revisionUpdate(qint64 rev)
     {
         emit revisionChanged(rev);
     }
 
 public slots:
     void open() Q_DECL_OVERRIDE
     {
     }
     void close() Q_DECL_OVERRIDE
     {
     }
 };
 
 class SINKTEST_EXPORT TestResourceFacade : public Sink::GenericFacade<Sink::ApplicationDomain::Event>
 {
 public:
     TestResourceFacade(const Sink::ResourceContext &resourceContext)
         : Sink::GenericFacade<Sink::ApplicationDomain::Event>(resourceContext)
     {
     }
     virtual ~TestResourceFacade()
     {
     }
 };
 
 class SINKTEST_EXPORT TestMailResourceFacade : public Sink::GenericFacade<Sink::ApplicationDomain::Mail>
 {
 public:
     TestMailResourceFacade(const Sink::ResourceContext &resourceContext)
         : Sink::GenericFacade<Sink::ApplicationDomain::Mail>(resourceContext)
     {
     }
     virtual ~TestMailResourceFacade()
     {
     }
 };
 
 class SINKTEST_EXPORT TestResource : public Sink::GenericResource
 {
 public:
     TestResource(const Sink::ResourceContext &resourceContext, QSharedPointer<Sink::Pipeline> pipeline) : Sink::GenericResource(resourceContext, pipeline)
     {
     }
 };
 
 template <typename DomainType>
 QByteArray createCommand(const DomainType &domainObject, DomainTypeAdaptorFactoryInterface &domainTypeAdaptorFactory)
 {
     flatbuffers::FlatBufferBuilder entityFbb;
     domainTypeAdaptorFactory.createBuffer(domainObject, entityFbb);
     flatbuffers::FlatBufferBuilder fbb;
     auto type = fbb.CreateString(Sink::ApplicationDomain::getTypeName<DomainType>().toStdString().data());
     auto delta = fbb.CreateVector<uint8_t>(entityFbb.GetBufferPointer(), entityFbb.GetSize());
     Sink::Commands::CreateEntityBuilder builder(fbb);
     builder.add_domainType(type);
     builder.add_delta(delta);
     auto location = builder.Finish();
     Sink::Commands::FinishCreateEntityBuffer(fbb, location);
     return QByteArray(reinterpret_cast<const char *>(fbb.GetBufferPointer()), fbb.GetSize());
 }