cutelyst 5.0.0
A C++ Web Framework built on top of Qt, using the simple approach of Catalyst (Perl) framework.
application.cpp
1/*
2 * SPDX-FileCopyrightText: (C) 2013-2022 Daniel Nicoletti <dantti12@gmail.com>
3 * SPDX-License-Identifier: BSD-3-Clause
4 */
5#include "application_p.h"
6#include "common.h"
7#include "config.h"
8#include "context_p.h"
9#include "controller.h"
10#include "controller_p.h"
11#include "dispatchtype.h"
12#include "enginerequest.h"
13#include "request.h"
14#include "request_p.h"
15#include "response.h"
16#include "response_p.h"
17#include "stats.h"
18#include "utils.h"
19#include "view.h"
20
21#include <QJsonDocument>
22#include <QtCore/QCoreApplication>
23#include <QtCore/QDataStream>
24#include <QtCore/QDir>
25#include <QtCore/QFileInfo>
26#include <QtCore/QLocale>
27#include <QtCore/QPluginLoader>
28#include <QtCore/QStringList>
29#include <QtCore/QTranslator>
30
31Q_LOGGING_CATEGORY(CUTELYST_DISPATCHER, "cutelyst.dispatcher", QtWarningMsg)
32Q_LOGGING_CATEGORY(CUTELYST_DISPATCHER_PATH, "cutelyst.dispatcher.path", QtWarningMsg)
33Q_LOGGING_CATEGORY(CUTELYST_DISPATCHER_CHAINED, "cutelyst.dispatcher.chained", QtWarningMsg)
34Q_LOGGING_CATEGORY(CUTELYST_CONTROLLER, "cutelyst.controller", QtWarningMsg)
35Q_LOGGING_CATEGORY(CUTELYST_CORE, "cutelyst.core", QtWarningMsg)
36Q_LOGGING_CATEGORY(CUTELYST_ENGINE, "cutelyst.engine", QtWarningMsg)
37Q_LOGGING_CATEGORY(CUTELYST_UPLOAD, "cutelyst.upload", QtWarningMsg)
38Q_LOGGING_CATEGORY(CUTELYST_MULTIPART, "cutelyst.multipart", QtWarningMsg)
39Q_LOGGING_CATEGORY(CUTELYST_VIEW, "cutelyst.view", QtWarningMsg)
40Q_LOGGING_CATEGORY(CUTELYST_REQUEST, "cutelyst.request", QtWarningMsg)
41Q_LOGGING_CATEGORY(CUTELYST_RESPONSE, "cutelyst.response", QtWarningMsg)
42Q_LOGGING_CATEGORY(CUTELYST_STATS, "cutelyst.stats", QtWarningMsg)
43Q_LOGGING_CATEGORY(CUTELYST_COMPONENT, "cutelyst.component", QtWarningMsg)
44
45using namespace Cutelyst;
46using namespace Qt::Literals::StringLiterals;
47
49 : QObject(parent)
50 , d_ptr(new ApplicationPrivate)
51{
52 Q_D(Application);
53
54 d->q_ptr = this;
55
56 qRegisterMetaType<ParamsMultiMap>();
57
58 d->dispatcher = new Dispatcher(this);
59
60 loadTranslations(u"cutelystcore"_s);
61}
62
64{
65 delete d_ptr;
66}
67
69{
70 qCDebug(CUTELYST_CORE) << "Default Application::init called on pid:"
72 return true;
73}
74
76{
77 qCDebug(CUTELYST_CORE) << "Default Application::postFork called on pid:"
79 return true;
80}
81
83{
84 Q_D(Application);
85 return d->headers;
86}
87
89{
90 Q_D(Application);
91 d->headers.setHeader("X-Cutelyst"_ba, QByteArrayLiteral(CUTELYST_VERSION));
92}
93
95{
96 Q_D(Application);
97 if (d->plugins.contains(plugin)) {
98 return false;
99 }
100 d->plugins.append(plugin);
101 return true;
102}
103
105{
106 Q_D(Application);
107 const auto name = QString::fromLatin1(controller->metaObject()->className());
108 if (d->controllersHash.contains(name)) {
109 return false;
110 }
111 d->controllersHash.insert(name, controller);
112 d->controllers.append(controller);
113 return true;
114}
115
117{
118 Q_D(Application);
119 if (d->views.contains(view->name())) {
120 qCWarning(CUTELYST_CORE) << "Not registering View." << view->metaObject()->className()
121 << "There is already a view with this name:" << view->name();
122 return false;
123 }
124 d->views.insert(view->name(), view);
125 return true;
126}
127
129{
130 Q_D(Application);
131 if (d->dispatchers.contains(dispatcher)) {
132 return false;
133 }
134 d->dispatchers.append(dispatcher);
135 return true;
136}
137
139{
140 Q_D(Application);
141
142 auto it = d->factories.constFind(name);
143 if (it != d->factories.constEnd()) {
144 ComponentFactory *factory = it.value();
145 if (factory) {
146 return factory->createComponent(parent);
147 } else {
148 return nullptr;
149 }
150 }
151
152 const QByteArrayList dirs = QByteArrayList{QByteArrayLiteral(CUTELYST_PLUGINS_DIR)} +
153 qgetenv("CUTELYST_PLUGINS_DIR").split(';');
154 for (const QByteArray &dir : dirs) {
155 Component *component = d->createComponentPlugin(name, parent, QString::fromLocal8Bit(dir));
156 if (component) {
157 return component;
158 }
159 }
160 qCDebug(CUTELYST_CORE) << "Did not find plugin" << name << "on" << dirs << "for" << parent;
161
162 return nullptr;
163}
164
165const char *Application::cutelystVersion() noexcept
166{
167 return CUTELYST_VERSION;
168}
169
171{
172 Q_D(const Application);
173 return d->controllers;
174}
175
177{
178 Q_D(const Application);
179 return d->views.value(name);
180}
181
182QVariant Application::config(const QString &key, const QVariant &defaultValue) const
183{
184 Q_D(const Application);
185 auto it = d->config.constFind(key);
186 if (it != d->config.constEnd()) {
187 return it.value();
188 }
189 return defaultValue;
190}
191
193{
194 Q_D(const Application);
195 return d->dispatcher;
196}
197
199{
200 Q_D(const Application);
201 return d->dispatcher->dispatchers();
202}
203
205{
206 Q_D(const Application);
207 return d->plugins;
208}
209
210QVariantMap Application::config() const noexcept
211{
212 Q_D(const Application);
213 return d->config;
214}
215
217{
218 QDir home = config(u"home"_s).toString();
219 return home.absoluteFilePath(path);
220}
221
223{
224 QDir home = config(u"home"_s).toString();
225 return home.absoluteFilePath(path.join(u'/'));
226}
227
228bool Cutelyst::Application::inited() const noexcept
229{
230 Q_D(const Application);
231 return d->init;
232}
233
235{
236 Q_D(const Application);
237 return d->engine;
238}
239
240void Application::setConfig(const QString &key, const QVariant &value)
241{
242 Q_D(Application);
243 d->config.insert(key, value);
244}
245
247{
248 Q_D(Application);
249
250 if (d->init) {
251 return true;
252 }
253 d->init = true;
254
255 d->useStats = CUTELYST_STATS().isDebugEnabled();
256 d->engine = engine;
257 d->config = engine->config(u"Cutelyst"_s);
258
259 d->setupHome();
260
261 // Call the virtual application init
262 // to setup Controllers plugins stuff
263 if (init()) {
264 d->setupChildren(children());
265
266 bool zeroCore = engine->workerCore() == 0;
267
268 QVector<QStringList> tablePlugins;
269 for (Plugin *pluginItem : std::as_const(d->plugins)) {
270 if (pluginItem->objectName().isEmpty()) {
271 pluginItem->setObjectName(
272 QString::fromLatin1(pluginItem->metaObject()->className()));
273 }
274 tablePlugins.append({pluginItem->objectName()});
275 // Configure plugins
276 pluginItem->setup(this);
277 }
278
279 if (zeroCore && !tablePlugins.isEmpty()) {
280 qCDebug(CUTELYST_CORE)
281 << Utils::buildTable(tablePlugins, {}, u"Loaded plugins:"_s).constData();
282 }
283
284 if (zeroCore) {
285 QVector<QStringList> tableDataHandlers;
286 tableDataHandlers.append({u"application/x-www-form-urlencoded"_s});
287 tableDataHandlers.append({u"application/json"_s});
288 tableDataHandlers.append({u"multipart/form-data"_s});
289 qCDebug(CUTELYST_CORE)
290 << Utils::buildTable(tableDataHandlers, {}, u"Loaded Request Data Handlers:"_s)
291 .constData();
292
293 qCDebug(CUTELYST_CORE) << "Loaded dispatcher"
294 << QString::fromLatin1(d->dispatcher->metaObject()->className());
295 qCDebug(CUTELYST_CORE)
296 << "Using engine" << QString::fromLatin1(d->engine->metaObject()->className());
297 }
298
299 QString home = d->config.value(u"home"_s).toString();
300 if (home.isEmpty()) {
301 if (zeroCore) {
302 qCDebug(CUTELYST_CORE) << "Couldn't find home";
303 }
304 } else {
305 QFileInfo homeInfo(home);
306 if (homeInfo.isDir()) {
307 if (zeroCore) {
308 qCDebug(CUTELYST_CORE) << "Found home" << home;
309 }
310 } else {
311 if (zeroCore) {
312 qCDebug(CUTELYST_CORE) << "Home" << home << "doesn't exist";
313 }
314 }
315 }
316
318 QStringList controllerNames = d->controllersHash.keys();
319 controllerNames.sort();
320 for (const QString &controller : std::as_const(controllerNames)) {
321 table.append({controller, u"Controller"_s});
322 }
323
324 for (View *viewItem : std::as_const(d->views)) {
325 if (viewItem->reverse().isEmpty()) {
326 const QString className =
327 QString::fromLatin1(viewItem->metaObject()->className()) + u"->execute";
328 viewItem->setReverse(className);
329 }
330 table.append({viewItem->reverse(), u"View"_s});
331 }
332
333 if (zeroCore && !table.isEmpty()) {
334 qCDebug(CUTELYST_CORE) << Utils::buildTable(table,
335 {
336 u"Class"_s,
337 u"Type"_s,
338 },
339 u"Loaded components:"_s)
340 .constData();
341 }
342
343 for (Controller *controller : std::as_const(d->controllers)) {
344 controller->d_ptr->init(this, d->dispatcher);
345 }
346
347 d->dispatcher->setupActions(d->controllers, d->dispatchers, d->engine->workerCore() == 0);
348
349 if (zeroCore) {
350 qCInfo(CUTELYST_CORE) << qPrintable(u"%1 powered by Cutelyst %2, Qt %3."_s.arg(
353 QString::fromLatin1(qVersion())));
354 }
355
356 Q_EMIT preForked(this);
357
358 return true;
359 }
360
361 return false;
362}
363
365{
366 Q_D(Application);
367
368 auto priv = new ContextPrivate(this, d->engine, d->dispatcher, d->plugins);
369 auto c = new Context(priv);
370
371 request->context = c;
372 priv->engineRequest = request;
373 priv->response = new Response(d->headers, request);
374 priv->request = new Request(request);
375 priv->locale = d->defaultLocale;
376
377 if (d->useStats) {
378 priv->stats = new Stats(request);
379 }
380
381 // Process request
382 bool skipMethod = false;
383 Q_EMIT beforePrepareAction(c, &skipMethod);
384
385 if (!skipMethod) {
386 static bool log = CUTELYST_REQUEST().isEnabled(QtDebugMsg);
387 if (log) {
388 d->logRequest(priv->request);
389 }
390
391 d->dispatcher->prepareAction(c);
392
394
395 d->dispatcher->dispatch(c);
396
397 if (request->status & EngineRequest::Async) {
398 return;
399 }
400
402 }
403
404 c->finalize();
405}
406
408{
409 Q_D(Application);
410
411 if (!postFork()) {
412 return false;
413 }
414
415 if (!std::ranges::all_of(d->controllers, [this](Controller *controller) {
416 return controller->postFork(this);
417 })) {
418 return false;
419 }
420
421 Q_EMIT postForked(this);
422
423 return true;
424}
425
426void Application::addTranslator(const QLocale &locale, QTranslator *translator)
427{
428 Q_D(Application);
429 Q_ASSERT_X(translator, "add translator to application", "invalid QTranslator object");
430 auto it = d->translators.find(locale);
431 if (it != d->translators.end()) {
432 it.value().prepend(translator);
433 } else {
434 d->translators.insert(locale, QVector<QTranslator *>(1, translator));
435 }
436}
437
438void Application::addTranslator(const QString &locale, QTranslator *translator)
439{
440 addTranslator(QLocale(locale), translator);
441}
442
443void Application::addTranslators(const QLocale &locale, const QVector<QTranslator *> &translators)
444{
445 Q_D(Application);
446 Q_ASSERT_X(!translators.empty(), "add translators to application", "empty translators vector");
447 auto transIt = d->translators.find(locale);
448 if (transIt != d->translators.end()) {
449 for (auto it = translators.crbegin(); it != translators.crend(); ++it) {
450 transIt.value().prepend(*it);
451 }
452 } else {
453 d->translators.insert(locale, translators);
454 }
455}
456
457namespace {
458void replacePercentN(QString *result, int n)
459{
460 if (n >= 0) {
461 auto percentPos = 0;
462 auto len = 0;
463 while ((percentPos = result->indexOf(u'%', percentPos + len)) != -1) {
464 len = 1;
465 QString fmt;
466 if (result->at(percentPos + len) == u'L') {
467 ++len;
468 fmt = u"%L1"_s;
469 } else {
470 fmt = u"%1"_s;
471 }
472 if (result->at(percentPos + len) == u'n') {
473 fmt = fmt.arg(n);
474 ++len;
475 result->replace(percentPos, len, fmt);
476 len = fmt.length();
477 }
478 }
479 }
480}
481} // namespace
482
484 const char *context,
485 const char *sourceText,
486 const char *disambiguation,
487 int n) const
488{
489 QString result;
490
491 if (!sourceText) {
492 return result;
493 }
494
495 Q_D(const Application);
496
497 const QVector<QTranslator *> translators = d->translators.value(locale);
498 if (translators.empty()) {
499 result = QString::fromUtf8(sourceText);
500 replacePercentN(&result, n);
501 return result;
502 }
503
504 for (QTranslator *translator : translators) {
505 result = translator->translate(context, sourceText, disambiguation, n);
506 if (!result.isEmpty()) {
507 break;
508 }
509 }
510
511 if (result.isEmpty()) {
512 result = QString::fromUtf8(sourceText);
513 }
514
515 replacePercentN(&result, n);
516 return result;
517}
518
520 const QString &directory,
521 const QString &prefix,
522 const QString &suffix)
523{
524 loadTranslationsFromDir(filename, directory, prefix, suffix);
525}
526
528 const QString &directory,
529 const QString &prefix,
530 const QString &suffix)
531{
532 QVector<QLocale> locales;
533
534 if (Q_LIKELY(!filename.isEmpty())) {
535 const QString _dir = directory.isEmpty() ? QStringLiteral(CUTELYST_I18N_DIR) : directory;
536 const QDir i18nDir(_dir);
537 if (Q_LIKELY(i18nDir.exists())) {
538 const QString _prefix = prefix.isEmpty() ? u"."_s : prefix;
539 const QString _suffix = suffix.isEmpty() ? u".qm"_s : suffix;
540 const QStringList namesFilter = QStringList({filename + _prefix + u'*' + _suffix});
541
542 const QFileInfoList tsFiles = i18nDir.entryInfoList(namesFilter, QDir::Files);
543 if (Q_LIKELY(!tsFiles.empty())) {
544 locales.reserve(tsFiles.size());
545 for (const QFileInfo &ts : tsFiles) {
546 const QString fn = ts.fileName();
547 const int prefIdx = fn.indexOf(_prefix);
548 const QString locString =
549 fn.mid(prefIdx + _prefix.length(),
550 fn.length() - prefIdx - _suffix.length() - _prefix.length());
551 QLocale loc(locString);
552 if (Q_LIKELY(loc.language() != QLocale::C)) {
553 auto trans = new QTranslator(this);
554 if (Q_LIKELY(trans->load(loc, filename, _prefix, _dir))) {
555 addTranslator(loc, trans);
556 locales.append(loc);
557 qCDebug(CUTELYST_CORE) << "Loaded translations for" << loc << "from"
558 << ts.absoluteFilePath();
559 } else {
560 delete trans;
561 qCWarning(CUTELYST_CORE) << "Can not load translations for" << loc
562 << "from" << ts.absoluteFilePath();
563 }
564 } else {
565 qCWarning(CUTELYST_CORE)
566 << "Can not load translations for invalid locale string" << locString;
567 }
568 }
569 locales.squeeze();
570 } else {
571 qCWarning(CUTELYST_CORE)
572 << "Can not find translation files for" << filename << "in directory" << _dir;
573 }
574 } else {
575 qCWarning(CUTELYST_CORE)
576 << "Can not load translations from not existing directory:" << _dir;
577 }
578 } else {
579 qCWarning(CUTELYST_CORE) << "Can not load translations for empty file name.";
580 }
581
582 return locales;
583}
584
586 const QString &filename)
587{
588 QVector<QLocale> locales;
589
590 if (Q_LIKELY(!directory.isEmpty() && !filename.isEmpty())) {
591 const QDir dir(directory);
592 if (Q_LIKELY(dir.exists())) {
593 const auto dirs = dir.entryList(QDir::AllDirs);
594 if (Q_LIKELY(!dirs.empty())) {
595 locales.reserve(dirs.size());
596 for (const QString &subDir : dirs) {
597 const QString relFn = subDir + u'/' + filename;
598 if (dir.exists(relFn)) {
599 const QLocale l(subDir);
600 if (Q_LIKELY(l.language() != QLocale::C)) {
601 auto trans = new QTranslator(this);
602 const QFileInfo fi(dir, relFn);
603 if (Q_LIKELY(trans->load(
604 l, fi.baseName(), QString(), fi.absolutePath(), fi.suffix()))) {
605 addTranslator(l, trans);
606 locales.append(l);
607 qCDebug(CUTELYST_CORE) << "Loaded translations for" << l << "from"
608 << fi.absoluteFilePath();
609 } else {
610 delete trans;
611 qCWarning(CUTELYST_CORE) << "Can not load translations for" << l
612 << "from" << fi.absoluteFilePath();
613 }
614 } else {
615 qCWarning(CUTELYST_CORE)
616 << "Can not load translations for invalid locale string:" << subDir;
617 }
618 }
619 }
620 locales.squeeze();
621 } else {
622 qCWarning(CUTELYST_CORE) << "Can not find locale dirs under" << directory;
623 }
624 } else {
625 qCWarning(CUTELYST_CORE)
626 << "Can not load translations from not existing directory:" << directory;
627 }
628 } else {
629 qCWarning(CUTELYST_CORE)
630 << "Can not load translations for empty file name or directory name";
631 }
632
633 return locales;
634}
635
637{
638 Q_D(const Application);
639 return d->defaultLocale;
640}
641
643{
644 Q_D(Application);
645 d->defaultLocale = locale;
646}
647
648void Cutelyst::ApplicationPrivate::setupHome()
649{
650 // Hook the current directory in config if "home" is not set
651 if (!config.contains(u"home"_s)) {
652 config.insert(u"home"_s, QDir::currentPath());
653 }
654
655 if (!config.contains(u"root"_s)) {
656 QDir home = config.value(u"home"_s).toString();
657 config.insert(u"root"_s, home.absoluteFilePath(u"root"_s));
658 }
659}
660
661void ApplicationPrivate::setupChildren(const QObjectList &children)
662{
663 Q_Q(Application);
664 for (QObject *child : children) {
665 auto controller = qobject_cast<Controller *>(child);
666 if (controller) {
667 q->registerController(controller);
668 continue;
669 }
670
671 auto plugin = qobject_cast<Plugin *>(child);
672 if (plugin) {
673 q->registerPlugin(plugin);
674 continue;
675 }
676
677 auto view = qobject_cast<View *>(child);
678 if (view) {
679 q->registerView(view);
680 continue;
681 }
682
683 auto dispatchType = qobject_cast<DispatchType *>(child);
684 if (dispatchType) {
685 q->registerDispatcher(dispatchType);
686 continue;
687 }
688 }
689}
690
691void Cutelyst::ApplicationPrivate::logRequest(const Request *req)
692{
693 QString path = req->path();
694 if (path.isEmpty()) {
695 path = u"/"_s;
696 }
697 qCDebug(CUTELYST_REQUEST) << req->method() << "request for" << path << "from"
698 << req->addressString();
699
700 ParamsMultiMap params = req->queryParameters();
701 if (!params.isEmpty()) {
702 logRequestParameters(params, u"Query Parameters are:"_s);
703 }
704
705 params = req->bodyParameters();
706 if (!params.isEmpty()) {
707 logRequestParameters(params, u"Body Parameters are:"_s);
708 }
709
710 const auto bodyData = req->bodyData();
711 if (bodyData.typeId() == QMetaType::QJsonDocument) {
712 const auto doc = bodyData.toJsonDocument();
713 qCDebug(CUTELYST_REQUEST).noquote() << "JSON body:\n"
715 }
716
717 const auto uploads = req->uploads();
718 if (!uploads.isEmpty()) {
719 logRequestUploads(uploads);
720 }
721}
722
723void Cutelyst::ApplicationPrivate::logRequestParameters(const ParamsMultiMap &params,
724 const QString &title)
725{
727 for (const auto &[key, value] : params.asKeyValueRange()) {
728 table.append({key, value});
729 }
730 qCDebug(CUTELYST_REQUEST) << Utils::buildTable(table,
731 {
732 u"Parameter"_s,
733 u"Value"_s,
734 },
735 title)
736 .constData();
737}
738
739void Cutelyst::ApplicationPrivate::logRequestUploads(const QVector<Cutelyst::Upload *> &uploads)
740{
742 for (const Upload *upload : uploads) {
743 table.append({upload->name(),
744 upload->filename(),
745 QString::fromLatin1(upload->contentType()),
746 QString::number(upload->size())});
747 }
748 qCDebug(CUTELYST_REQUEST) << Utils::buildTable(table,
749 {
750 u"Parameter"_s,
751 u"Filename"_s,
752 u"Type"_s,
753 u"Size"_s,
754 },
755 u"File Uploads are:"_s)
756 .constData();
757}
758
759Component *ApplicationPrivate::createComponentPlugin(const QString &name,
760 QObject *parent,
761 const QString &directory)
762{
763 Component *component = nullptr;
764 ComponentFactory *factory = nullptr;
765
766 auto matchMetadata = [name](const QJsonObject &metadata) {
767 const QJsonObject json = metadata[u"MetaData"].toObject();
768 qCDebug(CUTELYST_CORE) << "Found plugin metadata" << json;
769 return json[u"name"].toString() == name;
770 };
771
772 auto createComponent = [name, parent, &factory](QObject *plugin) -> Component * {
773 factory = qobject_cast<ComponentFactory *>(plugin);
774 if (factory) {
775 return factory->createComponent(parent);
776 }
777 return nullptr;
778 };
779
780 // Load static plugins
781 const QList<QStaticPlugin> &staticPlugins = QPluginLoader::staticPlugins();
782 for (const QStaticPlugin &plugin : staticPlugins) {
783 if (matchMetadata(plugin.metaData())) {
784 component = createComponent(plugin.instance());
785 if (component) {
786 break;
787 }
788
789 qCCritical(CUTELYST_CORE)
790 << "Could not create a component for static plugin" << plugin.metaData();
791 }
792 }
793
794 if (factory && component) {
795 factories.insert(name, factory);
796 return component;
797 }
798
799 QDir pluginsDir(directory);
800 QPluginLoader loader;
801 const auto pluginFiles = pluginsDir.entryList(QDir::Files);
802 for (const QString &fileName : pluginFiles) {
803 loader.setFileName(pluginsDir.absoluteFilePath(fileName));
804
805 if (matchMetadata(loader.metaData())) {
806 component = createComponent(loader.instance());
807 if (component) {
808 break;
809 }
810
811 qCCritical(CUTELYST_CORE)
812 << "Could not create a component for plugin" << fileName << loader.metaData();
813 }
814 }
815
816 if (factory) {
817 factories.insert(name, factory);
818 }
819
820 return component;
821}
822
823#include "moc_application.cpp"
The Cutelyst application.
Definition application.h:66
Engine * engine() const noexcept
QVector< Controller * > controllers() const noexcept
void afterDispatch(Cutelyst::Context *c)
bool setup(Engine *engine)
QVector< QLocale > loadTranslationsFromDir(const QString &filename, const QString &directory={}, const QString &prefix=QStringLiteral("."), const QString &suffix=QStringLiteral(".qm"))
void handleRequest(Cutelyst::EngineRequest *request)
void beforePrepareAction(Cutelyst::Context *c, bool *skipMethod)
Application(QObject *parent=nullptr)
void setConfig(const QString &key, const QVariant &value)
QVariantMap config() const noexcept
Dispatcher * dispatcher() const noexcept
bool registerPlugin(Plugin *plugin)
bool registerController(Controller *controller)
bool registerDispatcher(DispatchType *dispatcher)
QString pathTo(const QString &path) const
Headers & defaultHeaders() noexcept
QString translate(const QLocale &locale, const char *context, const char *sourceText, const char *disambiguation=nullptr, int n=-1) const
View * view(QStringView name={}) const
bool inited() const noexcept
void beforeDispatch(Cutelyst::Context *c)
void preForked(Cutelyst::Application *app)
void setDefaultLocale(const QLocale &locale)
QVector< Plugin * > plugins() const noexcept
void addTranslator(const QLocale &locale, QTranslator *translator)
QLocale defaultLocale() const noexcept
bool registerView(View *view)
void addTranslators(const QLocale &locale, const QVector< QTranslator * > &translators)
QVector< DispatchType * > dispatchers() const noexcept
static const char * cutelystVersion() noexcept
QVector< QLocale > loadTranslationsFromDirs(const QString &directory, const QString &filename)
Component * createComponentPlugin(const QString &name, QObject *parent=nullptr)
void loadTranslations(const QString &filename, const QString &directory={}, const QString &prefix={}, const QString &suffix={})
virtual bool init()
void postForked(Cutelyst::Application *app)
virtual bool postFork()
virtual Component * createComponent(QObject *parent=nullptr)=0
The Cutelyst Component base class.
Definition component.h:30
QString name() const noexcept
Definition component.cpp:33
The Cutelyst Context.
Definition context.h:42
Cutelyst Controller base class.
Definition controller.h:56
Abstract class to described a dispatch type.
The Cutelyst Dispatcher.
Definition dispatcher.h:29
The Cutelyst Engine.
Definition engine.h:20
int workerCore() const
Definition engine.cpp:67
QVariantMap config(const QString &entity) const
Definition engine.cpp:122
Container for HTTP headers.
Definition headers.h:24
Base class for Cutelyst Plugins.
Definition plugin.h:25
A request.
Definition request.h:42
QString addressString() const
Definition request.cpp:40
QVector< Upload * > uploads() const
Definition request.cpp:378
ParamsMultiMap bodyParameters() const
Definition request.cpp:219
ParamsMultiMap queryParameters() const
Definition request.cpp:255
A Cutelyst response.
Definition response.h:29
Cutelyst Upload handles file upload requests.
Definition upload.h:26
Abstract View component for Cutelyst.
Definition view.h:25
The Cutelyst namespace holds all public Cutelyst API.
qint64 applicationPid()
QString absoluteFilePath(const QString &fileName) const const
QString currentPath()
QFileInfoList entryInfoList(QDir::Filters filters, QDir::SortFlags sort) const const
QStringList entryList(QDir::Filters filters, QDir::SortFlags sort) const const
bool exists() const const
QString absoluteFilePath() const const
QString absolutePath() const const
QString baseName() const const
bool isDir() const const
QString suffix() const const
QByteArray toJson(QJsonDocument::JsonFormat format) const const
QJsonObject::iterator insert(QLatin1StringView key, const QJsonValue &value)
void append(QList::parameter_type value)
QList::const_reverse_iterator crbegin() const const
QList::const_reverse_iterator crend() const const
bool empty() const const
bool isEmpty() const const
void reserve(qsizetype size)
void squeeze()
T value(qsizetype i) const const
QLocale::Language language() const const
const char * className() const const
bool isEmpty() const const
Q_EMITQ_EMIT
const QObjectList & children() const const
virtual const QMetaObject * metaObject() const const
QObject * parent() const const
void setFileName(const QString &fileName)
QObject * instance()
QJsonObject metaData() const const
QList< QStaticPlugin > staticPlugins()
QString arg(Args &&... args) const const
const QChar at(qsizetype position) const const
QString fromLatin1(QByteArrayView str)
QString fromLocal8Bit(QByteArrayView str)
QString fromUtf8(QByteArrayView str)
qsizetype indexOf(QChar ch, qsizetype from, Qt::CaseSensitivity cs) const const
QString & insert(qsizetype position, QChar ch)
bool isEmpty() const const
qsizetype length() const const
QString mid(qsizetype position, qsizetype n) const const
QString number(double n, char format, int precision)
QString & replace(QChar before, QChar after, Qt::CaseSensitivity cs)
QString join(QChar separator) const const
void sort(Qt::CaseSensitivity cs)
QJsonDocument toJsonDocument() const const