sdk.hpp

Go to the documentation of this file.

/*
 * This file is part of libkazv.
 * SPDX-FileCopyrightText: 2020-2021 Tusooa Zhu <tusooa@kazv.moe>
 * SPDX-License-Identifier: AGPL-3.0-or-later
 */
 
#pragma once
#include <libkazv-config.hpp>
#include <lager/store.hpp>
 
#include <random>
 
#include <store.hpp>
 
#include "sdk-model.hpp"
#include "sdk-model-cursor-tag.hpp"
#include "client.hpp"
#include "thread-safety-helper.hpp"
#include "verification-tracker.hpp"
#include "random-generator.hpp"
 
 
namespace Kazv
{
    template<class EventLoop, class Xform, class ...Enhancers>
    class Sdk
    {
        using ModelT = ::Kazv::SdkModel;
        using ClientT = ::Kazv::ClientModel;
        using ActionT = typename ModelT::Action;
        using CursorT = lager::reader<ModelT>;
        using CursorTSP = std::shared_ptr<CursorT>;
 
        using StoreT = decltype(
            makeStore<ActionT>(
                std::declval<ModelT>(),
                &ModelT::update,
                std::declval<EventLoop>(),
                lager::with_deps(
                    std::ref(detail::declref<JobInterface>()),
                    std::ref(detail::declref<EventInterface>()),
                    lager::dep::as<SdkModelCursorKey>(std::declval<std::function<CursorTSP()>>()),
                    std::ref(detail::declref<RandomInterface>()),
                    std::ref(detail::declref<VerificationTracker>())
#ifdef KAZV_USE_THREAD_SAFETY_HELPER
                    , std::ref(detail::declref<EventLoopThreadIdKeeper>())
#endif
                    ),
                std::declval<Enhancers>()...)
            );
 
        using DepsT = lager::deps<JobInterface &, EventInterface &, SdkModelCursorKey, RandomInterface &, VerificationTracker &
#ifdef KAZV_USE_THREAD_SAFETY_HELPER
                                  , EventLoopThreadIdKeeper &
#endif
                                  >;
 
        using ContextT = Context<ActionT, DepsT>;
    public:
        Sdk(ModelT model,
            JobInterface &jobHandler,
            EventInterface &eventEmitter,
            EventLoop &&eventLoop,
            Xform &&xform,
            Enhancers &&...enhancers)
            : m_d(std::make_unique<Private>(
                      std::move(model), jobHandler, eventEmitter,
                      std::forward<EventLoop>(eventLoop), std::forward<Xform>(xform),
                      std::forward<Enhancers>(enhancers)...)) {}
 
        ContextT context() const {
            return m_d->store;
        }
 
        Client client() const {
            return {Client::InEventLoopTag{}, ContextT(m_d->store)};
        }
 
        template<class EL>
        auto createSecondaryRoot(EL &&eventLoop, ModelT initialModel = ModelT{}) const {
            auto secondaryStore = lager::make_store<ModelT>(
                std::move(initialModel),
                std::forward<EL>(eventLoop),
                lager::with_reducer([](auto &&, auto next) { return next; }));
 
            lager::context<ModelT> secondaryCtx = secondaryStore;
 
            context().createResolvedPromise({})
                .then([secondaryCtx, d=m_d.get()](auto &&) {
                          lager::watch(*(d->sdk),
                                       [secondaryCtx](auto next) { secondaryCtx.dispatch(std::move(next)); });
                      });
 
            return secondaryStore;
        }
 
        Client clientFromSecondaryRoot(lager::reader<ModelT> sr) const {
            return Client(sr, ContextT(m_d->store));
        }
 
    private:
        struct Private
        {
            Private(ModelT model,
                    JobInterface &jobHandler,
                    EventInterface &eventEmitter,
                    EventLoop &&eventLoop,
                    Xform &&xform,
                    Enhancers &&...enhancers)
                : rg(RandomInterface{RandomDeviceGenerator{}})
                , vt(VerificationUtils::DeviceIdentity())
                , store(makeStore<ActionT>(
                            std::move(model),
                            &ModelT::update,
                            std::forward<EventLoop>(eventLoop),
                            lager::with_deps(
                                std::ref(jobHandler),
                                std::ref(eventEmitter),
                                lager::dep::as<SdkModelCursorKey>(
                                    std::function<CursorTSP()>([this] { return sdk; })),
                                std::ref(rg.value()),
                                std::ref(vt)
#ifdef KAZV_USE_THREAD_SAFETY_HELPER
                                , std::ref(keeper)
#endif
                                ),
                            std::forward<Enhancers>(enhancers)...))
                , sdk(std::make_shared<lager::reader<ModelT>>(store.reader().xform(std::forward<Xform>(xform))))
                {
#ifdef KAZV_USE_THREAD_SAFETY_HELPER
                    store.context().createResolvedPromise(EffectStatus{})
                        .then([this](auto &&) {
                                  keeper.set(std::this_thread::get_id());
                              });
#endif
                }
#ifdef KAZV_USE_THREAD_SAFETY_HELPER
            EventLoopThreadIdKeeper keeper;
#endif
            std::optional<RandomInterface> rg;
            VerificationTracker vt;
            StoreT store;
            CursorTSP sdk;
        };
 
        std::unique_ptr<Private> m_d;
    };
 
    template<class EventLoop, class Xform, class ...Enhancers>
    inline auto makeSdk(SdkModel sdk,
                        JobInterface &jobHandler,
                        EventInterface &eventEmitter,
                        EventLoop &&eventLoop,
                        Xform &&xform,
                        Enhancers &&...enhancers)
        -> Sdk<EventLoop, Xform, Enhancers...>
    {
        return { std::move(sdk),
                 jobHandler,
                 eventEmitter,
                 std::forward<EventLoop>(eventLoop),
                 std::forward<Xform>(xform),
                 std::forward<Enhancers>(enhancers)... };
    }
 
    inline std::size_t makeDefaultSdkWithCryptoRandomSize()
    {
        return Crypto::constructRandomSize();
    }
 
    template<class EventLoop, class Xform, class ...Enhancers>
    [[deprecated("Use deterministic makeDefaultSdkWithCryptoRandom instead. In the future, this will be removed.")]]
    inline auto makeDefaultEncryptedSdk(
        JobInterface &jobHandler,
        EventInterface &eventEmitter,
        EventLoop &&eventLoop,
        Xform &&xform,
        Enhancers &&...enhancers)
        -> Sdk<EventLoop, Xform, Enhancers...>
    {
        auto m = SdkModel{};
        m.client.crypto = Crypto(RandomTag{}, genRandomData(makeDefaultSdkWithCryptoRandomSize()));
 
        return makeSdk(std::move(m),
                       jobHandler,
                       eventEmitter,
                       std::forward<EventLoop>(eventLoop),
                       std::forward<Xform>(xform),
                       std::forward<Enhancers>(enhancers)...);
    }
 
    template<class PH, class Xform, class ...Enhancers>
    inline auto makeDefaultSdkWithCryptoRandom(
        RandomData random,
        JobInterface &jobHandler,
        EventInterface &eventEmitter,
        PH &&ph,
        Xform &&xform,
        Enhancers &&...enhancers)
        -> Sdk<PH, Xform, Enhancers...>
    {
        auto m = SdkModel{};
        m.client.crypto = Crypto(RandomTag{}, std::move(random));
 
        return makeSdk(std::move(m),
                       jobHandler,
                       eventEmitter,
                       std::forward<PH>(ph),
                       std::forward<Xform>(xform),
                       std::forward<Enhancers>(enhancers)...);
    }
 
 
    inline auto withRandomGenerator(RandomInterface &random)
    {
        return lager::with_deps(std::ref(random));
    }
}