23 #include "blockcontext.h"
24 #include "exception.h"
26 #include "rendercontext.h"
30 static const char *
const __loadedBlocks =
"__loadedBlocks";
33 #define BLOCK_CONTEXT_KEY 0
35 BlockNodeFactory::BlockNodeFactory(QObject *parent)
42 #if QT_VERSION < QT_VERSION_CHECK(5, 14, 0)
43 const auto expr = tagContent.split(QLatin1Char(
' '), QString::SkipEmptyParts);
45 const auto expr = tagContent.split(QLatin1Char(
' '), Qt::SkipEmptyParts);
48 if (expr.size() != 2) {
50 QStringLiteral(
"block tag takes one argument"));
53 const auto blockName = expr.at(1);
55 auto loadedBlocksVariant = p->property(__loadedBlocks);
56 QVariantList blockVariantList;
58 if (loadedBlocksVariant.isValid()
59 && loadedBlocksVariant.userType() == qMetaTypeId<QVariantList>()) {
60 blockVariantList = loadedBlocksVariant.value<QVariantList>();
61 for (
auto &item : blockVariantList) {
62 const auto blockNodeName = item.toString();
64 if (blockNodeName == blockName) {
67 QStringLiteral(
"'block' tag with name '%1' appears more than once.")
73 blockVariantList.append(blockName);
74 loadedBlocksVariant =
QVariant(blockVariantList);
76 p->setProperty(__loadedBlocks, loadedBlocksVariant);
79 const auto list = p->
parse(n, QStringLiteral(
"endblock"));
82 const QStringList acceptableBlocks{QStringLiteral(
"endblock"),
83 QStringLiteral(
"endblock ") + blockName};
84 if (!acceptableBlocks.contains(endBlock.content)) {
85 p->invalidBlockTag(endBlock, QStringLiteral(
"endblock"), acceptableBlocks);
93 BlockNode::BlockNode(
const QString &name, QObject *parent)
94 :
Node(parent), m_name(name), m_stream(0)
96 qRegisterMetaType<Cutelee::SafeString>(
"Cutelee::SafeString");
99 BlockNode::~BlockNode() {}
101 void BlockNode::setNodeList(
const NodeList &list)
const { m_list = list; }
110 if (blockContext.isEmpty()) {
113 c->
insert(QStringLiteral(
"block"),
115 const_cast<QObject *
>(
static_cast<const QObject *
>(
this))));
119 auto block =
static_cast<const BlockNode *
>(blockContext.pop(m_name));
120 variant.setValue(blockContext);
125 const auto list = block->m_list;
128 block->setNodeList(list);
129 block->m_context = c;
130 block->m_stream = stream;
131 c->
insert(QStringLiteral(
"block"),
133 const_cast<QObject *
>(
static_cast<const QObject *
>(block))));
134 list.render(stream, c);
138 blockContext.push(m_name, push);
139 variant.setValue(blockContext);
149 const auto blockContext = variant.value<
BlockContext>();
150 auto block = blockContext.getBlock(m_name);
153 QTextStream superTextStream(&superContent);
154 auto superStream = m_stream->
clone(&superTextStream);
162 NodeList BlockNode::nodeList()
const {
return m_list; }
164 QString BlockNode::name()
const {
return m_name; }
Node * getNode(const QString &tagContent, Parser *p) const override
void render(OutputStream *stream, Context *c) const override
SafeString getSuper() const
Base class for all NodeFactories.
The Context class holds the context to render a Template with.
RenderContext * renderContext() const
void insert(const QString &name, QObject *object)
An exception for use when implementing template tags.
A list of Nodes with some convenience API for rendering them.
void render(OutputStream *stream, Context *c) const
Base class for all nodes.
The OutputStream class is used to render templates to a QTextStream.
virtual std::shared_ptr< OutputStream > clone(QTextStream *stream) const
The Parser class processes a string template into a tree of nodes.
NodeList parse(Node *parent, const QStringList &stopAt={})
bool contains(Node *const scopeNode) const
QVariant & data(const Node *const scopeNode)
A QString wrapper class for containing whether a string is safe or needs to be escaped.
Cutelee::SafeString markSafe(const Cutelee::SafeString &input)
Utility functions used throughout Cutelee.