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_export.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_EXPORT 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 *pluginPtr : pluginsConst) {
            auto p = qobject_cast<T>(pluginPtr);
            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 = {},
                                             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