application.h

/*
 * Copyright (C) 2013-2017 Daniel Nicoletti <dantti12@gmail.com>
 *
 * 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) any later version.
 *
 * 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, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 */
#ifndef CUTELYST_APPLICATION_H
#define CUTELYST_APPLICATION_H

#include <QtCore/QObject>
#include <QtCore/QVariant>
#include <QtCore/QLocale>
#include <QtCore/QVector>

#include <Cutelyst/cutelyst_global.h>

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;

    View *view(const QString &name = QString()) const;

    QVariant config(const QString &key, const QVariant &defaultValue = QVariant()) const;

    Dispatcher *dispatcher() const;

    QVector<DispatchType *> dispatchers() const;

    QVector<Plugin *> plugins() const;

    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;

    QString pathTo(const QString &path) const;

    QString pathTo(const QStringList &path) const;

    bool inited() const;

    Engine *engine() const;

    Component *createComponentPlugin(const QString &name, QObject *parent = nullptr);

    static const char *cutelystVersion();

    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 = QString(), const QString &prefix = QString(), const QString &suffix = QString());

    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);

protected:
    virtual bool init();

    virtual bool postFork();

    Headers &defaultHeaders();

    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;
};

}

#define CutelystApplicationInterface_iid "org.cutelyst.CutelystApplicationInterface"

Q_DECLARE_INTERFACE(Cutelyst::Application, CutelystApplicationInterface_iid)

#endif // CUTELYST_APPLICATION_H