context.h

/*
 * SPDX-FileCopyrightText: (C) 2013-2023 Daniel Nicoletti <dantti12@gmail.com>
 * SPDX-License-Identifier: BSD-3-Clause
 */
#pragma once
 
#include <Cutelyst/async.h>
#include <Cutelyst/cutelyst_export.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_EXPORT 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();
 
    [[nodiscard]] bool error() const noexcept;
 
    void appendError(const QString &error);
 
    [[nodiscard]] QStringList errors() const noexcept;
 
    [[nodiscard]] bool state() const noexcept;
 
    void setState(bool state) noexcept;
 
    [[nodiscard]] Engine *engine() const noexcept;
 
    [[nodiscard]] Application *app() const noexcept;
 
    [[nodiscard]] Response *response() const noexcept;
 
    [[nodiscard]] Response *res() const noexcept;
 
    [[nodiscard]] Action *action() const noexcept;
 
    [[nodiscard]] QString actionName() const noexcept;
 
    [[nodiscard]] QString ns() const noexcept;
 
    [[nodiscard]] Request *request() const noexcept;
 
    [[nodiscard]] Request *req() const noexcept;
 
    [[nodiscard]] Dispatcher *dispatcher() const noexcept;
 
    [[nodiscard]] QString controllerName() const noexcept;
 
    [[nodiscard]] Controller *controller() const noexcept;
 
    [[nodiscard]] Controller *controller(QStringView name) const;
 
    [[nodiscard]] View *view(QStringView name = {}) const;
 
    [[nodiscard]] View *customView() const noexcept;
 
    bool setCustomView(QStringView name);
 
    void stash(const QVariantHash &unite);
 
    [[nodiscard]] QVariantHash &stash();
 
    [[nodiscard]] QVariant stash(const QString &key) const;
 
    [[nodiscard]] 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);
 
    [[nodiscard]] QStack<Component *> stack() const noexcept;
 
    [[nodiscard]] QUrl uriFor(const QString &path               = {},
                              const QStringList &args           = {},
                              const ParamsMultiMap &queryValues = {}) const;
 
    [[nodiscard]] inline QUrl uriFor(const QString &path, const ParamsMultiMap &queryValues) const;
 
    [[nodiscard]] QUrl uriFor(Action *action,
                              const QStringList &captures       = {},
                              const QStringList &args           = {},
                              const ParamsMultiMap &queryValues = {}) const;
 
    [[nodiscard]] inline QUrl uriFor(Action *action, const ParamsMultiMap &queryValues) const;
 
    [[nodiscard]] QUrl uriForAction(QStringView path,
                                    const QStringList &captures       = {},
                                    const QStringList &args           = {},
                                    const ParamsMultiMap &queryValues = {}) const;
 
    [[nodiscard]] inline QUrl uriForAction(QStringView 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(QStringView action);
 
    [[nodiscard]] Action *getAction(QStringView action, QStringView ns = {}) const;
 
    [[nodiscard]] QVector<Action *> getActions(QStringView action, QStringView ns = {}) const;
 
    [[nodiscard]] 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);
 
    [[nodiscard]] QLocale locale() const noexcept;
 
    void setLocale(const QLocale &locale);
 
    [[nodiscard]] QVariant config(const QString &key, const QVariant &defaultValue = {}) const;
 
    [[nodiscard]] QVariantMap config() const noexcept;
 
    [[nodiscard]] QString translate(const char *context,
                                    const char *sourceText,
                                    const char *disambiguation = nullptr,
                                    int n                      = -1) const;
    [[nodiscard]] 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(QStringView 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 *)