mirror of
https://github.com/pantor/inja.git
synced 2026-04-03 22:58:51 +00:00
587 lines
20 KiB
C++
587 lines
20 KiB
C++
// Copyright (c) 2020 Pantor. All rights reserved.
|
|
|
|
#ifndef INCLUDE_INJA_RENDERER_HPP_
|
|
#define INCLUDE_INJA_RENDERER_HPP_
|
|
|
|
#include <algorithm>
|
|
#include <numeric>
|
|
#include <string>
|
|
#include <utility>
|
|
#include <vector>
|
|
|
|
#include <nlohmann/json.hpp>
|
|
|
|
#include "config.hpp"
|
|
#include "exceptions.hpp"
|
|
#include "node.hpp"
|
|
#include "template.hpp"
|
|
#include "utils.hpp"
|
|
|
|
namespace inja {
|
|
|
|
/*!
|
|
* \brief Class for rendering a Template with data.
|
|
*/
|
|
class Renderer : public NodeVisitor {
|
|
using Op = FunctionStorage::Operation;
|
|
|
|
const RenderConfig config;
|
|
const Template *current_template;
|
|
const TemplateStorage &template_storage;
|
|
const FunctionStorage &function_storage;
|
|
|
|
const json *json_input;
|
|
std::ostream *output_stream;
|
|
|
|
json json_loop_data;
|
|
json* current_loop_data = &json_loop_data["loop"];
|
|
|
|
std::vector<std::shared_ptr<json>> json_tmp_stack;
|
|
std::stack<const json*> json_eval_stack;
|
|
std::stack<const JsonNode*> not_found_stack;
|
|
|
|
bool truthy(const json* data) const {
|
|
if (data->empty()) {
|
|
return false;
|
|
} else if (data->is_number()) {
|
|
return (*data != 0);
|
|
} else if (data->is_string()) {
|
|
return !data->empty();
|
|
}
|
|
|
|
try {
|
|
return data->get<bool>();
|
|
} catch (json::type_error &e) {
|
|
throw JsonError(e.what());
|
|
}
|
|
}
|
|
|
|
void print_json(const json* value) {
|
|
if (value->is_string()) {
|
|
*output_stream << value->get_ref<const std::string &>();
|
|
} else {
|
|
*output_stream << value->dump();
|
|
}
|
|
}
|
|
|
|
const std::shared_ptr<json> eval_expression_list(const ExpressionListNode& expression_list) {
|
|
for (auto& expression : expression_list.rpn_output) {
|
|
expression->accept(*this);
|
|
}
|
|
|
|
if (json_eval_stack.empty()) {
|
|
throw_renderer_error("empty expression", expression_list);
|
|
}
|
|
|
|
if (json_eval_stack.size() != 1) {
|
|
throw_renderer_error("malformed expression", expression_list);
|
|
}
|
|
|
|
auto result = json_eval_stack.top();
|
|
json_eval_stack.pop();
|
|
|
|
if (!result) {
|
|
if (not_found_stack.empty()) {
|
|
throw_renderer_error("expression could not be evaluated", expression_list);
|
|
}
|
|
|
|
auto node = not_found_stack.top();
|
|
not_found_stack.pop();
|
|
|
|
throw_renderer_error("variable '" + static_cast<std::string>(node->name) + "' not found", *node);
|
|
}
|
|
return std::make_shared<json>(*result);
|
|
}
|
|
|
|
void throw_renderer_error(const std::string &message, const AstNode& node) {
|
|
SourceLocation loc = get_source_location(current_template->content, node.pos);
|
|
throw RenderError(message, loc);
|
|
}
|
|
|
|
template<size_t N, bool throw_not_found=true>
|
|
std::array<const json*, N> get_arguments(const AstNode& node) {
|
|
if (json_eval_stack.size() < N) {
|
|
throw_renderer_error("function needs " + std::to_string(N) + " variables, but has only found " + std::to_string(json_eval_stack.size()), node);
|
|
}
|
|
|
|
std::array<const json*, N> result;
|
|
for (size_t i = 0; i < N; i += 1) {
|
|
result[N - i - 1] = json_eval_stack.top();
|
|
json_eval_stack.pop();
|
|
|
|
if (!result[N - i - 1]) {
|
|
auto json_node = not_found_stack.top();
|
|
not_found_stack.pop();
|
|
|
|
if (throw_not_found) {
|
|
throw_renderer_error("variable '" + static_cast<std::string>(json_node->name) + "' not found", *json_node);
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
template<bool throw_not_found=true>
|
|
Arguments get_argument_vector(size_t N, const AstNode& node) {
|
|
Arguments result {N};
|
|
for (size_t i = 0; i < N; i += 1) {
|
|
result[N - i - 1] = json_eval_stack.top();
|
|
json_eval_stack.pop();
|
|
|
|
if (!result[N - i - 1]) {
|
|
auto json_node = not_found_stack.top();
|
|
not_found_stack.pop();
|
|
|
|
if (throw_not_found) {
|
|
throw_renderer_error("variable '" + static_cast<std::string>(json_node->name) + "' not found", *json_node);
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
void visit(const BlockNode& node) {
|
|
for (auto& n : node.nodes) {
|
|
n->accept(*this);
|
|
}
|
|
}
|
|
|
|
void visit(const TextNode& node) {
|
|
*output_stream << node.content;
|
|
}
|
|
|
|
void visit(const ExpressionNode&) { }
|
|
|
|
void visit(const LiteralNode& node) {
|
|
json_eval_stack.push(&node.value);
|
|
}
|
|
|
|
void visit(const JsonNode& node) {
|
|
auto ptr = json::json_pointer(node.ptr);
|
|
|
|
try {
|
|
// First try to evaluate as a loop variable
|
|
if (json_loop_data.contains(ptr)) {
|
|
json_eval_stack.push(&json_loop_data.at(ptr));
|
|
} else {
|
|
json_eval_stack.push(&json_input->at(ptr));
|
|
}
|
|
|
|
} catch (std::exception &) {
|
|
// Try to evaluate as a no-argument callback
|
|
auto function_data = function_storage.find_function(node.name, 0);
|
|
if (function_data.operation == FunctionStorage::Operation::Callback) {
|
|
Arguments empty_args {};
|
|
auto value = std::make_shared<json>(function_data.callback(empty_args));
|
|
json_tmp_stack.push_back(value);
|
|
json_eval_stack.push(value.get());
|
|
|
|
} else {
|
|
json_eval_stack.push(nullptr);
|
|
not_found_stack.emplace(&node);
|
|
}
|
|
}
|
|
}
|
|
|
|
void visit(const FunctionNode& node) {
|
|
std::shared_ptr<json> result_ptr;
|
|
|
|
switch (node.operation) {
|
|
case Op::Not: {
|
|
auto args = get_arguments<1>(node);
|
|
result_ptr = std::make_shared<json>(!truthy(args[0]));
|
|
json_tmp_stack.push_back(result_ptr);
|
|
json_eval_stack.push(result_ptr.get());
|
|
} break;
|
|
case Op::And: {
|
|
auto args = get_arguments<2>(node);
|
|
result_ptr = std::make_shared<json>(truthy(args[0]) && truthy(args[1]));
|
|
json_tmp_stack.push_back(result_ptr);
|
|
json_eval_stack.push(result_ptr.get());
|
|
} break;
|
|
case Op::Or: {
|
|
auto args = get_arguments<2>(node);
|
|
result_ptr = std::make_shared<json>(truthy(args[0]) || truthy(args[1]));
|
|
json_tmp_stack.push_back(result_ptr);
|
|
json_eval_stack.push(result_ptr.get());
|
|
} break;
|
|
case Op::In: {
|
|
auto args = get_arguments<2>(node);
|
|
result_ptr = std::make_shared<json>(std::find(args[1]->begin(), args[1]->end(), *args[0]) != args[1]->end());
|
|
json_tmp_stack.push_back(result_ptr);
|
|
json_eval_stack.push(result_ptr.get());
|
|
} break;
|
|
case Op::Equal: {
|
|
auto args = get_arguments<2>(node);
|
|
result_ptr = std::make_shared<json>(*args[0] == *args[1]);
|
|
json_tmp_stack.push_back(result_ptr);
|
|
json_eval_stack.push(result_ptr.get());
|
|
} break;
|
|
case Op::NotEqual: {
|
|
auto args = get_arguments<2>(node);
|
|
result_ptr = std::make_shared<json>(*args[0] != *args[1]);
|
|
json_tmp_stack.push_back(result_ptr);
|
|
json_eval_stack.push(result_ptr.get());
|
|
} break;
|
|
case Op::Greater: {
|
|
auto args = get_arguments<2>(node);
|
|
result_ptr = std::make_shared<json>(*args[0] > *args[1]);
|
|
json_tmp_stack.push_back(result_ptr);
|
|
json_eval_stack.push(result_ptr.get());
|
|
} break;
|
|
case Op::GreaterEqual: {
|
|
auto args = get_arguments<2>(node);
|
|
result_ptr = std::make_shared<json>(*args[0] >= *args[1]);
|
|
json_tmp_stack.push_back(result_ptr);
|
|
json_eval_stack.push(result_ptr.get());
|
|
} break;
|
|
case Op::Less: {
|
|
auto args = get_arguments<2>(node);
|
|
result_ptr = std::make_shared<json>(*args[0] < *args[1]);
|
|
json_tmp_stack.push_back(result_ptr);
|
|
json_eval_stack.push(result_ptr.get());
|
|
} break;
|
|
case Op::LessEqual: {
|
|
auto args = get_arguments<2>(node);
|
|
result_ptr = std::make_shared<json>(*args[0] <= *args[1]);
|
|
json_tmp_stack.push_back(result_ptr);
|
|
json_eval_stack.push(result_ptr.get());
|
|
} break;
|
|
case Op::Add: {
|
|
auto args = get_arguments<2>(node);
|
|
if (args[0]->is_string() && args[1]->is_string()) {
|
|
result_ptr = std::make_shared<json>(args[0]->get<std::string>() + args[1]->get<std::string>());
|
|
json_tmp_stack.push_back(result_ptr);
|
|
} else if (args[0]->is_number_integer() && args[1]->is_number_integer()) {
|
|
result_ptr = std::make_shared<json>(args[0]->get<int>() + args[1]->get<int>());
|
|
json_tmp_stack.push_back(result_ptr);
|
|
} else {
|
|
result_ptr = std::make_shared<json>(args[0]->get<double>() + args[1]->get<double>());
|
|
json_tmp_stack.push_back(result_ptr);
|
|
}
|
|
json_eval_stack.push(result_ptr.get());
|
|
} break;
|
|
case Op::Subtract: {
|
|
auto args = get_arguments<2>(node);
|
|
if (args[0]->is_number_integer() && args[1]->is_number_integer()) {
|
|
result_ptr = std::make_shared<json>(args[0]->get<int>() - args[1]->get<int>());
|
|
json_tmp_stack.push_back(result_ptr);
|
|
} else {
|
|
result_ptr = std::make_shared<json>(args[0]->get<double>() - args[1]->get<double>());
|
|
json_tmp_stack.push_back(result_ptr);
|
|
}
|
|
json_eval_stack.push(result_ptr.get());
|
|
} break;
|
|
case Op::Multiplication: {
|
|
auto args = get_arguments<2>(node);
|
|
if (args[0]->is_number_integer() && args[1]->is_number_integer()) {
|
|
result_ptr = std::make_shared<json>(args[0]->get<int>() * args[1]->get<int>());
|
|
json_tmp_stack.push_back(result_ptr);
|
|
} else {
|
|
result_ptr = std::make_shared<json>(args[0]->get<double>() * args[1]->get<double>());
|
|
json_tmp_stack.push_back(result_ptr);
|
|
}
|
|
json_eval_stack.push(result_ptr.get());
|
|
} break;
|
|
case Op::Division: {
|
|
auto args = get_arguments<2>(node);
|
|
if (args[1]->get<double>() == 0) {
|
|
throw_renderer_error("division by zero", node);
|
|
}
|
|
result_ptr = std::make_shared<json>(args[0]->get<double>() / args[1]->get<double>());
|
|
json_tmp_stack.push_back(result_ptr);
|
|
json_eval_stack.push(result_ptr.get());
|
|
} break;
|
|
case Op::Power: {
|
|
auto args = get_arguments<2>(node);
|
|
if (args[0]->is_number_integer() && args[1]->get<int>() >= 0) {
|
|
int result = std::pow(args[0]->get<int>(), args[1]->get<int>());
|
|
result_ptr = std::make_shared<json>(std::move(result));
|
|
json_tmp_stack.push_back(result_ptr);
|
|
} else {
|
|
double result = std::pow(args[0]->get<int>(), args[1]->get<int>());
|
|
result_ptr = std::make_shared<json>(std::move(result));
|
|
json_tmp_stack.push_back(result_ptr);
|
|
}
|
|
json_eval_stack.push(result_ptr.get());
|
|
} break;
|
|
case Op::Modulo: {
|
|
auto args = get_arguments<2>(node);
|
|
result_ptr = std::make_shared<json>(args[0]->get<int>() % args[1]->get<int>());
|
|
json_tmp_stack.push_back(result_ptr);
|
|
json_eval_stack.push(result_ptr.get());
|
|
} break;
|
|
case Op::At: {
|
|
auto args = get_arguments<2>(node);
|
|
json_eval_stack.push(&args[0]->at(args[1]->get<int>()));
|
|
} break;
|
|
case Op::Default: {
|
|
auto default_arg = get_arguments<1>(node)[0];
|
|
auto test_arg = get_arguments<1, false>(node)[0];
|
|
json_eval_stack.push(test_arg ? test_arg : default_arg);
|
|
} break;
|
|
case Op::DivisibleBy: {
|
|
auto args = get_arguments<2>(node);
|
|
int divisor = args[1]->get<int>();
|
|
result_ptr = std::make_shared<json>((divisor != 0) && (args[0]->get<int>() % divisor == 0));
|
|
json_tmp_stack.push_back(result_ptr);
|
|
json_eval_stack.push(result_ptr.get());
|
|
} break;
|
|
case Op::Even: {
|
|
result_ptr = std::make_shared<json>(get_arguments<1>(node)[0]->get<int>() % 2 == 0);
|
|
json_tmp_stack.push_back(result_ptr);
|
|
json_eval_stack.push(result_ptr.get());
|
|
} break;
|
|
case Op::Exists: {
|
|
auto &&name = get_arguments<1>(node)[0]->get_ref<const std::string &>();
|
|
result_ptr = std::make_shared<json>(json_input->contains(json::json_pointer(JsonNode(name, 0).ptr)));
|
|
json_tmp_stack.push_back(result_ptr);
|
|
json_eval_stack.push(result_ptr.get());
|
|
} break;
|
|
case Op::ExistsInObject: {
|
|
auto args = get_arguments<2>(node);
|
|
auto &&name = args[1]->get_ref<const std::string &>();
|
|
result_ptr = std::make_shared<json>(args[0]->find(name) != args[0]->end());
|
|
json_tmp_stack.push_back(result_ptr);
|
|
json_eval_stack.push(result_ptr.get());
|
|
} break;
|
|
case Op::First: {
|
|
auto result = &get_arguments<1>(node)[0]->front();
|
|
json_eval_stack.push(result);
|
|
} break;
|
|
case Op::Float: {
|
|
result_ptr = std::make_shared<json>(std::stod(get_arguments<1>(node)[0]->get_ref<const std::string &>()));
|
|
json_tmp_stack.push_back(result_ptr);
|
|
json_eval_stack.push(result_ptr.get());
|
|
} break;
|
|
case Op::Int: {
|
|
result_ptr = std::make_shared<json>(std::stoi(get_arguments<1>(node)[0]->get_ref<const std::string &>()));
|
|
json_tmp_stack.push_back(result_ptr);
|
|
json_eval_stack.push(result_ptr.get());
|
|
} break;
|
|
case Op::Last: {
|
|
auto result = &get_arguments<1>(node)[0]->back();
|
|
json_eval_stack.push(result);
|
|
} break;
|
|
case Op::Length: {
|
|
auto val = get_arguments<1>(node)[0];
|
|
if (val->is_string()) {
|
|
result_ptr = std::make_shared<json>(val->get_ref<const std::string &>().length());
|
|
} else {
|
|
result_ptr = std::make_shared<json>(val->size());
|
|
}
|
|
json_tmp_stack.push_back(result_ptr);
|
|
json_eval_stack.push(result_ptr.get());
|
|
} break;
|
|
case Op::Lower: {
|
|
std::string result = get_arguments<1>(node)[0]->get<std::string>();
|
|
std::transform(result.begin(), result.end(), result.begin(), ::tolower);
|
|
result_ptr = std::make_shared<json>(std::move(result));
|
|
json_tmp_stack.push_back(result_ptr);
|
|
json_eval_stack.push(result_ptr.get());
|
|
} break;
|
|
case Op::Max: {
|
|
auto args = get_arguments<1>(node);
|
|
auto result = std::max_element(args[0]->begin(), args[0]->end());
|
|
json_eval_stack.push(&(*result));
|
|
} break;
|
|
case Op::Min: {
|
|
auto args = get_arguments<1>(node);
|
|
auto result = std::min_element(args[0]->begin(), args[0]->end());
|
|
json_eval_stack.push(&(*result));
|
|
} break;
|
|
case Op::Odd: {
|
|
result_ptr = std::make_shared<json>(get_arguments<1>(node)[0]->get<int>() % 2 != 0);
|
|
json_tmp_stack.push_back(result_ptr);
|
|
json_eval_stack.push(result_ptr.get());
|
|
} break;
|
|
case Op::Range: {
|
|
std::vector<int> result(get_arguments<1>(node)[0]->get<int>());
|
|
std::iota(result.begin(), result.end(), 0);
|
|
result_ptr = std::make_shared<json>(std::move(result));
|
|
json_tmp_stack.push_back(result_ptr);
|
|
json_eval_stack.push(result_ptr.get());
|
|
} break;
|
|
case Op::Round: {
|
|
auto args = get_arguments<2>(node);
|
|
int precision = args[1]->get<int>();
|
|
double result = std::round(args[0]->get<double>() * std::pow(10.0, precision)) / std::pow(10.0, precision);
|
|
result_ptr = std::make_shared<json>(std::move(result));
|
|
json_tmp_stack.push_back(result_ptr);
|
|
json_eval_stack.push(result_ptr.get());
|
|
} break;
|
|
case Op::Sort: {
|
|
result_ptr = std::make_shared<json>(get_arguments<1>(node)[0]->get<std::vector<json>>());
|
|
std::sort(result_ptr->begin(), result_ptr->end());
|
|
json_tmp_stack.push_back(result_ptr);
|
|
json_eval_stack.push(result_ptr.get());
|
|
} break;
|
|
case Op::Upper: {
|
|
std::string result = get_arguments<1>(node)[0]->get<std::string>();
|
|
std::transform(result.begin(), result.end(), result.begin(), ::toupper);
|
|
result_ptr = std::make_shared<json>(std::move(result));
|
|
json_tmp_stack.push_back(result_ptr);
|
|
json_eval_stack.push(result_ptr.get());
|
|
} break;
|
|
case Op::IsBoolean: {
|
|
result_ptr = std::make_shared<json>(get_arguments<1>(node)[0]->is_boolean());
|
|
json_tmp_stack.push_back(result_ptr);
|
|
json_eval_stack.push(result_ptr.get());
|
|
} break;
|
|
case Op::IsNumber: {
|
|
result_ptr = std::make_shared<json>(get_arguments<1>(node)[0]->is_number());
|
|
json_tmp_stack.push_back(result_ptr);
|
|
json_eval_stack.push(result_ptr.get());
|
|
} break;
|
|
case Op::IsInteger: {
|
|
result_ptr = std::make_shared<json>(get_arguments<1>(node)[0]->is_number_integer());
|
|
json_tmp_stack.push_back(result_ptr);
|
|
json_eval_stack.push(result_ptr.get());
|
|
} break;
|
|
case Op::IsFloat: {
|
|
result_ptr = std::make_shared<json>(get_arguments<1>(node)[0]->is_number_float());
|
|
json_tmp_stack.push_back(result_ptr);
|
|
json_eval_stack.push(result_ptr.get());
|
|
} break;
|
|
case Op::IsObject: {
|
|
result_ptr = std::make_shared<json>(get_arguments<1>(node)[0]->is_object());
|
|
json_tmp_stack.push_back(result_ptr);
|
|
json_eval_stack.push(result_ptr.get());
|
|
} break;
|
|
case Op::IsArray: {
|
|
result_ptr = std::make_shared<json>(get_arguments<1>(node)[0]->is_array());
|
|
json_tmp_stack.push_back(result_ptr);
|
|
json_eval_stack.push(result_ptr.get());
|
|
} break;
|
|
case Op::IsString: {
|
|
result_ptr = std::make_shared<json>(get_arguments<1>(node)[0]->is_string());
|
|
json_tmp_stack.push_back(result_ptr);
|
|
json_eval_stack.push(result_ptr.get());
|
|
} break;
|
|
case Op::Callback: {
|
|
auto args = get_argument_vector(node.number_args, node);
|
|
result_ptr = std::make_shared<json>(node.callback(args));
|
|
json_tmp_stack.push_back(result_ptr);
|
|
json_eval_stack.push(result_ptr.get());
|
|
} break;
|
|
case Op::ParenLeft:
|
|
case Op::ParenRight:
|
|
case Op::None:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void visit(const ExpressionListNode& node) {
|
|
print_json(eval_expression_list(node).get());
|
|
}
|
|
|
|
void visit(const StatementNode&) { }
|
|
|
|
void visit(const ForStatementNode&) { }
|
|
|
|
void visit(const ForArrayStatementNode& node) {
|
|
auto result = eval_expression_list(node.condition);
|
|
if (!result->is_array()) {
|
|
throw_renderer_error("object must be an array", node);
|
|
}
|
|
|
|
if (!current_loop_data->empty()) {
|
|
auto tmp = *current_loop_data; // Because of clang-3
|
|
(*current_loop_data)["parent"] = std::move(tmp);
|
|
}
|
|
|
|
for (auto it = result->begin(); it != result->end(); ++it) {
|
|
json_loop_data[static_cast<std::string>(node.value)] = *it;
|
|
|
|
size_t index = std::distance(result->begin(), it);
|
|
(*current_loop_data)["index"] = index;
|
|
(*current_loop_data)["index1"] = index + 1;
|
|
(*current_loop_data)["is_first"] = (index == 0);
|
|
(*current_loop_data)["is_last"] = (index == result->size() - 1);
|
|
|
|
node.body.accept(*this);
|
|
}
|
|
|
|
json_loop_data[static_cast<std::string>(node.value)].clear();
|
|
if (!(*current_loop_data)["parent"].empty()) {
|
|
auto tmp = (*current_loop_data)["parent"];
|
|
*current_loop_data = std::move(tmp);
|
|
} else {
|
|
current_loop_data = &json_loop_data["loop"];
|
|
}
|
|
}
|
|
|
|
void visit(const ForObjectStatementNode& node) {
|
|
auto result = eval_expression_list(node.condition);
|
|
if (!result->is_object()) {
|
|
throw_renderer_error("object must be an object", node);
|
|
}
|
|
|
|
if (!current_loop_data->empty()) {
|
|
(*current_loop_data)["parent"] = std::move(*current_loop_data);
|
|
}
|
|
|
|
for (auto it = result->begin(); it != result->end(); ++it) {
|
|
json_loop_data[static_cast<std::string>(node.key)] = it.key();
|
|
json_loop_data[static_cast<std::string>(node.value)] = it.value();
|
|
|
|
size_t index = std::distance(result->begin(), it);
|
|
(*current_loop_data)["index"] = index;
|
|
(*current_loop_data)["index1"] = index + 1;
|
|
(*current_loop_data)["is_first"] = (index == 0);
|
|
(*current_loop_data)["is_last"] = (index == result->size() - 1);
|
|
|
|
node.body.accept(*this);
|
|
}
|
|
|
|
json_loop_data[static_cast<std::string>(node.key)].clear();
|
|
json_loop_data[static_cast<std::string>(node.value)].clear();
|
|
if (!(*current_loop_data)["parent"].empty()) {
|
|
*current_loop_data = std::move((*current_loop_data)["parent"]);
|
|
} else {
|
|
current_loop_data = &json_loop_data["loop"];
|
|
}
|
|
}
|
|
|
|
void visit(const IfStatementNode& node) {
|
|
auto result = eval_expression_list(node.condition);
|
|
if (truthy(result.get())) {
|
|
node.true_statement.accept(*this);
|
|
} else if (node.has_false_statement) {
|
|
node.false_statement.accept(*this);
|
|
}
|
|
}
|
|
|
|
void visit(const IncludeStatementNode& node) {
|
|
auto sub_renderer = Renderer(config, template_storage, function_storage);
|
|
auto included_template_it = template_storage.find(node.file);
|
|
|
|
if (included_template_it != template_storage.end()) {
|
|
sub_renderer.render_to(*output_stream, included_template_it->second, *json_input, &json_loop_data);
|
|
} else if (config.throw_at_missing_includes) {
|
|
throw_renderer_error("include '" + node.file + "' not found", node);
|
|
}
|
|
}
|
|
|
|
public:
|
|
Renderer(const RenderConfig& config, const TemplateStorage &template_storage, const FunctionStorage &function_storage)
|
|
: config(config), template_storage(template_storage), function_storage(function_storage) { }
|
|
|
|
void render_to(std::ostream &os, const Template &tmpl, const json &data, json *loop_data = nullptr) {
|
|
output_stream = &os;
|
|
current_template = &tmpl;
|
|
json_input = &data;
|
|
if (loop_data) {
|
|
json_loop_data = *loop_data;
|
|
}
|
|
|
|
current_template->root.accept(*this);
|
|
|
|
json_tmp_stack.clear();
|
|
}
|
|
};
|
|
|
|
} // namespace inja
|
|
|
|
#endif // INCLUDE_INJA_RENDERER_HPP_
|