Application.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "corium/ApplicationContext.hpp"
#include "corium/EventSink.hpp"
#include "corium/ServiceRegistry.hpp"
#include "corium/internal/VariantIndex.hpp"
 
#include <utility>
 
namespace corium {
 
// Forward declaration of BasicRuntime for friendship
template <
    typename EventVariant,
    typename QueuePolicy,
    typename SignalPolicy,
    typename StoragePolicy,
    typename OverflowPolicy,
    typename TimerStoragePolicy,
    typename ProfilerPolicy
>
class BasicRuntime;
 
template <typename Derived, typename EventVariantOrBus = DefaultEvents, std::size_t MaxServices = 8>
class Application {
public:
    using EventVariant = internal::extract_event_variant_t<EventVariantOrBus>;
    using ServiceRegistryType = BasicServiceRegistry<MaxServices, EventVariant>;
    using ContextType = ApplicationContext<EventVariant>;
 
    Application() = default;
    ~Application()
    {
        shutdownServices();
        _context.detachFromRuntime();
    }
 
    Application(const Application&) = delete;
    Application& operator=(const Application&) = delete;
 
    Application(Application&&) = delete;
    Application& operator=(Application&&) = delete;
 
protected:
    template <typename Handler>
    bool on(Handler&& handler)
    {
        return _context.registerHandler(std::forward<Handler>(handler));
    }
 
    template <typename Filter, typename Handler>
        requires (std::is_invocable_r_v<bool, Filter&, const callable_event_type_t<Handler>&>)
    bool on(Filter&& filter, Handler&& handler)
    {
        return _context.registerFilteredHandler(std::forward<Filter>(filter), std::forward<Handler>(handler));
    }
 
    [[nodiscard]] EventSinkT<EventVariant> eventSink()
    {
        return _context.eventSink();
    }
 
    template <typename Rep, typename Period>
    TimerId postDelayed(EventVariant event, const std::chrono::duration<Rep, Period>& delay, EventPriority priority = EventPriority::Normal)
    {
        return _context.scheduleDelayed(std::move(event), delay, priority);
    }
 
    template <typename Rep, typename Period>
    TimerId postPeriodic(EventVariant event, const std::chrono::duration<Rep, Period>& interval, EventPriority priority = EventPriority::Normal)
    {
        return _context.schedulePeriodic(std::move(event), interval, priority);
    }
 
    bool cancelTimer(TimerId id) noexcept
    {
        return _context.cancelTimer(id);
    }
 
    void requestQuit()
    {
        _context.requestQuit();
    }
 
    [[nodiscard]] ServiceRegistryType& services() noexcept
    {
        return _serviceRegistry;
    }
 
    [[nodiscard]] const ServiceRegistryType& services() const noexcept
    {
        return _serviceRegistry;
    }
 
    template <typename ServiceType>
    [[nodiscard]] ServiceType* getService() const noexcept
    {
        return _serviceRegistry.template getService<ServiceType>();
    }
 
private:
    template <
        typename EV,
        typename QP,
        typename SP,
        typename STP,
        typename OP,
        typename TP,
        typename PP
    >
    friend class BasicRuntime;
 
    template <typename Registry>
    void configureServices(Registry& registry)
    {
        if constexpr (requires(Derived& d, Registry& r) { d.onConfigureServices(r); }) {
            static_cast<Derived*>(this)->onConfigureServices(registry);
        }
    }
 
    void initializeServices(EventSinkT<EventVariant> sink)
    {
        configureServices(_serviceRegistry);
        _serviceRegistry.initialize(BasicServiceContext<EventVariant>{sink});
    }
 
    void shutdownServices() noexcept
    {
        _serviceRegistry.shutdown();
    }
 
    void registerHandlers()
    {
        if constexpr (requires(Derived& d) { d.onRegisterHandlers(); }) {
            static_cast<Derived*>(this)->onRegisterHandlers();
        }
    }
 
    void initialize()
    {
        if constexpr (requires(Derived& d) { d.onInitialize(); }) {
            static_cast<Derived*>(this)->onInitialize();
        }
    }
 
    void shutdown()
    {
        if constexpr (requires(Derived& d) { d.onShutdown(); }) {
            static_cast<Derived*>(this)->onShutdown();
        }
    }
 
    void setContext(ApplicationContext<EventVariant> context)
    {
        _context = context;
        if constexpr (requires(Derived& d, ApplicationContext<EventVariant> c) { d.onSetContext(c); }) {
            static_cast<Derived*>(this)->onSetContext(context);
        }
    }
 
    void resetContext() noexcept
    {
        _context.reset();
    }
 
    ApplicationContext<EventVariant> _context;
    ServiceRegistryType _serviceRegistry;
};
 
} // namespace corium