application.h

/*
 * SPDX-FileCopyrightText: (C) 2013-2022 Daniel Nicoletti <dantti12@gmail.com>
 * SPDX-License-Identifier: BSD-3-Clause
 */
#ifndef CUTELYST_APPLICATION_H
#define CUTELYST_APPLICATION_H
 
#include <Cutelyst/cutelyst_global.h>
 
#include <QtCore/QLocale>
#include <QtCore/QObject>
#include <QtCore/QVariant>
#include <QtCore/QVector>
 
class QTranslator;
 
namespace Cutelyst {
 
#define CUTELYST_APPLICATION(x) \
    Q_PLUGIN_METADATA(x) \
    Q_INTERFACES(Cutelyst::Application)
 
class Context;
class Controller;
class Component;
class View;
class Dispatcher;
class DispatchType;
class Request;
class Response;
class Engine;
class EngineRequest;
class Plugin;
class Headers;
class ApplicationPrivate;
 
class CUTELYST_LIBRARY Application : public QObject
{
    Q_OBJECT
    Q_DECLARE_PRIVATE(Application)
public:
    explicit Application(QObject *parent = nullptr);
 
    virtual ~Application();
 
    QVector<Controller *> controllers() const noexcept;
 
    View *view(QStringView name = {}) const;
 
    QVariant config(const QString &key, const QVariant &defaultValue = {}) const;
 
    Dispatcher *dispatcher() const noexcept;
 
    QVector<DispatchType *> dispatchers() const noexcept;
 
    QVector<Plugin *> plugins() const noexcept;
 
    template <typename T>
    T plugin()
    {
        const auto pluginsConst = plugins();
        for (Plugin *plugin : pluginsConst) {
            auto p = qobject_cast<T>(plugin);
            if (p) {
                return p;
            }
        }
        return nullptr;
    }
 
    QVariantMap config() const noexcept;
 
    QString pathTo(const QString &path) const;
 
    QString pathTo(const QStringList &path) const;
 
    bool inited() const noexcept;
 
    Engine *engine() const noexcept;
 
    Component *createComponentPlugin(const QString &name, QObject *parent = nullptr);
 
    static const char *cutelystVersion() noexcept;
 
    void addTranslator(const QLocale &locale, QTranslator *translator);
 
    void addTranslator(const QString &locale, QTranslator *translator);
 
    void addTranslators(const QLocale &locale, const QVector<QTranslator *> &translators);
 
    QString translate(const QLocale &locale,
                      const char *context,
                      const char *sourceText,
                      const char *disambiguation = nullptr,
                      int n                      = -1) const;
 
    void loadTranslations(const QString &filename,
                          const QString &directory = {},
                          const QString &prefix    = {},
                          const QString &suffix    = {});
 
    QVector<QLocale> loadTranslationsFromDir(const QString &filename,
                                             const QString &directory = QString(),
                                             const QString &prefix    = QStringLiteral("."),
                                             const QString &suffix    = QStringLiteral(".qm"));
 
    QVector<QLocale> loadTranslationsFromDirs(const QString &directory, const QString &filename);
 
    [[nodiscard]] QLocale defaultLocale() const noexcept;
 
    void setDefaultLocale(const QLocale &locale);
 
protected:
    virtual bool init();
 
    virtual bool postFork();
 
    Headers &defaultHeaders() noexcept;
 
    void addXCutelystVersionHeader();
 
    bool registerPlugin(Plugin *plugin);
 
    bool registerController(Controller *controller);
 
    bool registerView(View *view);
 
    bool registerDispatcher(DispatchType *dispatcher);
 
Q_SIGNALS:
    void beforePrepareAction(Cutelyst::Context *c, bool *skipMethod);
 
    void beforeDispatch(Cutelyst::Context *c);
 
    void afterDispatch(Cutelyst::Context *c);
 
    void preForked(Cutelyst::Application *app);
 
    void postForked(Cutelyst::Application *app);
 
    void shuttingDown(Cutelyst::Application *app);
 
protected:
    void setConfig(const QString &key, const QVariant &value);
 
    friend class Engine;
    friend class Context;
 
    bool setup(Engine *engine);
 
    void handleRequest(Cutelyst::EngineRequest *request);
 
    bool enginePostFork();
 
    ApplicationPrivate *d_ptr;
};
 
} // namespace Cutelyst
 
#define CutelystApplicationInterface_iid "org.cutelyst.CutelystApplicationInterface"
 
Q_DECLARE_INTERFACE(Cutelyst::Application, CutelystApplicationInterface_iid)
 
#endif // CUTELYST_APPLICATION_H