context.h

/*
 * SPDX-FileCopyrightText: (C) 2013-2022 Daniel Nicoletti <dantti12@gmail.com>
 * SPDX-License-Identifier: BSD-3-Clause
 */
#ifndef CUTELYST_CONTEXT_H
#define CUTELYST_CONTEXT_H
 
#include <Cutelyst/async.h>
#include <Cutelyst/cutelyst_global.h>
#include <Cutelyst/request.h>
 
#include <QtCore/QObject>
#include <QtCore/QStack>
#include <QtCore/QStringList>
#include <QtCore/QUrl>
#include <QtCore/QVariant>
 
namespace Cutelyst {
 
class Action;
class Application;
class Component;
class Engine;
class Response;
class Dispatcher;
class Controller;
class View;
class Stats;
class Plugin;
class ContextPrivate;
 
class CUTELYST_LIBRARY Context : public QObject
{
    Q_OBJECT
    Q_PROPERTY(Action *action READ action CONSTANT)
    Q_PROPERTY(QString actionName READ actionName CONSTANT)
    Q_PROPERTY(QString ns READ ns CONSTANT)
    Q_PROPERTY(QString namespace READ ns CONSTANT)
    Q_PROPERTY(Request *req READ request CONSTANT)
    Q_PROPERTY(Request *request READ request CONSTANT)
    Q_PROPERTY(Controller *controller READ controller CONSTANT)
    Q_PROPERTY(QString controllerName READ controllerName CONSTANT)
    Q_PROPERTY(QVariantMap config READ config CONSTANT)
    Q_PROPERTY(bool state READ state CONSTANT)
public:
    Context(Application *app);
    virtual ~Context();
 
    bool error() const noexcept;
 
    void error(const QString &error);
 
    QStringList errors() const noexcept;
 
    bool state() const noexcept;
 
    void setState(bool state) noexcept;
 
    Engine *engine() const noexcept;
 
    Application *app() const noexcept;
 
    Response *response() const noexcept;
 
    Response *res() const noexcept;
 
    Action *action() const noexcept;
 
    QString actionName() const noexcept;
 
    QString ns() const noexcept;
 
    Request *request() const noexcept;
 
    Request *req() const noexcept;
 
    Dispatcher *dispatcher() const noexcept;
 
    QString controllerName() const;
 
    Controller *controller() const noexcept;
 
    Controller *controller(const QString &name) const;
 
    View *view(const QString &name) const;
 
    View *view(QStringView name = {}) const;
 
    View *customView() const noexcept;
 
    bool setCustomView(const QString &name);
 
    void stash(const QVariantHash &unite);
 
    QVariantHash &stash();
 
    QVariant stash(const QString &key) const;
 
    QVariant stash(const QString &key, const QVariant &defaultValue) const;
 
    QVariant stashTake(const QString &key);
 
    bool stashRemove(const QString &key);
 
    void setStash(const QString &key, const QVariant &value);
 
    void setStash(const QString &key, const ParamsMultiMap &map);
 
    QStack<Component *> stack() const noexcept;
 
    QUrl uriFor(const QString &path               = QString(),
                const QStringList &args           = QStringList(),
                const ParamsMultiMap &queryValues = ParamsMultiMap()) const;
 
    inline QUrl uriFor(const QString &path, const ParamsMultiMap &queryValues) const;
 
    QUrl uriFor(Action *action,
                const QStringList &captures       = QStringList(),
                const QStringList &args           = QStringList(),
                const ParamsMultiMap &queryValues = ParamsMultiMap()) const;
 
    inline QUrl uriFor(Action *action, const ParamsMultiMap &queryValues) const;
 
    QUrl uriForAction(const QString &path,
                      const QStringList &captures       = QStringList(),
                      const QStringList &args           = QStringList(),
                      const ParamsMultiMap &queryValues = ParamsMultiMap()) const;
 
    inline QUrl uriForAction(const QString &path, const ParamsMultiMap &queryValues) const;
 
    bool detached() const noexcept;
 
    void detach(Action *action = nullptr);
 
    void detachAsync() noexcept;
 
    void attachAsync();
 
    bool forward(Component *component);
 
    bool forward(const QString &action);
 
    Action *getAction(const QString &action, const QString &ns = {}) const;
 
    QVector<Action *> getActions(const QString &action, const QString &ns = {}) 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;
    }
 
    bool execute(Component *code);
 
    QLocale locale() const noexcept;
 
    void setLocale(const QLocale &locale);
 
    QVariant config(const QString &key, const QVariant &defaultValue = {}) const;
 
    QVariantMap config() const noexcept;
 
    QString translate(const char *context,
                      const char *sourceText,
                      const char *disambiguation = nullptr,
                      int n                      = -1) const;
    inline QString qtTrId(const char *id, int n = -1) const;
 
public Q_SLOTS:
    void finalize();
 
protected:
    Context(ContextPrivate *priv);
 
    friend class Application;
    friend class Action;
    friend class ActionChain;
    friend class DispatchType;
    friend class Plugin;
    friend class Engine;
    friend class Controller;
    friend class Async;
    ContextPrivate *d_ptr;
 
private:
    Q_DECLARE_PRIVATE(Context)
};
 
inline QUrl Context::uriFor(const QString &path, const ParamsMultiMap &queryValues) const
{
    return uriFor(path, QStringList(), queryValues);
}
 
inline QUrl Context::uriFor(Action *action, const ParamsMultiMap &queryValues) const
{
    return uriFor(action, QStringList(), QStringList(), queryValues);
}
 
inline QUrl Context::uriForAction(const QString &path, const ParamsMultiMap &queryValues) const
{
    return uriForAction(path, QStringList(), QStringList(), queryValues);
}
 
inline QString Context::qtTrId(const char *id, int n) const
{
    return translate(nullptr, id, nullptr, n);
}
 
} // namespace Cutelyst
 
Q_DECLARE_METATYPE(Cutelyst::Context *)
 
#endif // CUTELYST_CONTEXT_H