inja::Renderer Class Reference

Class for rendering a Template with data. More...

#include <inja.hpp>

Inheritance diagram for inja::Renderer:

Collaboration diagram for inja::Renderer:

Public Member Functions
	Renderer (const RenderConfig &config, const TemplateStorage &template_storage, const FunctionStorage &function_storage)
void	render_to (std::ostream &os, const Template &tmpl, const json &data, json *loop_data=nullptr)
Public Member Functions inherited from inja::NodeVisitor
virtual	~NodeVisitor ()=default

Private Types
using	Op = FunctionStorage::Operation

Private Member Functions
void	print_data (const std::shared_ptr< json > value)
const std::shared_ptr< json >	eval_expression_list (const ExpressionListNode &expression_list)
void	throw_renderer_error (const std::string &message, const AstNode &node)
void	make_result (const json &&result)
template<size_t N, size_t N_start = 0, bool throw_not_found = true>
std::array< const json *, N >	get_arguments (const FunctionNode &node)
template<bool throw_not_found = true>
Arguments	get_argument_vector (const FunctionNode &node)
void	visit (const BlockNode &node) override
void	visit (const TextNode &node) override
void	visit (const ExpressionNode &) override
void	visit (const LiteralNode &node) override
void	visit (const DataNode &node) override
void	visit (const FunctionNode &node) override
void	visit (const ExpressionListNode &node) override
void	visit (const StatementNode &) override
void	visit (const ForStatementNode &) override
void	visit (const ForArrayStatementNode &node) override
void	visit (const ForObjectStatementNode &node) override
void	visit (const IfStatementNode &node) override
void	visit (const IncludeStatementNode &node) override
void	visit (const ExtendsStatementNode &node) override
void	visit (const BlockStatementNode &node) override
void	visit (const SetStatementNode &node) override

Static Private Member Functions
static bool	truthy (const json *data)

Private Attributes
const RenderConfig	config
const TemplateStorage &	template_storage
const FunctionStorage &	function_storage
const Template *	current_template
size_t	current_level {0}
std::vector< const Template * >	template_stack
std::vector< const BlockStatementNode * >	block_statement_stack
const json *	data_input
std::ostream *	output_stream
json	additional_data
json *	current_loop_data = &additional_data["loop"]
std::vector< std::shared_ptr< json > >	data_tmp_stack
std::stack< const json * >	data_eval_stack
std::stack< const DataNode * >	not_found_stack
bool	break_rendering {false}

Detailed Description

Class for rendering a Template with data.

Definition at line 2205 of file inja.hpp.

Member Typedef Documentation

Op

using inja::Renderer::Op = FunctionStorage::Operation

private

Definition at line 2206 of file inja.hpp.

Constructor & Destructor Documentation

Renderer()

inja::Renderer::Renderer ( const RenderConfig & config, const TemplateStorage & template_storage, const FunctionStorage & function_storage )

inline

Definition at line 2816 of file inja.hpp.

            : config(config)
            , template_storage(template_storage)
            , function_storage(function_storage) {
        }

References config, function_storage, and template_storage.

Member Function Documentation

eval_expression_list()

const std::shared_ptr< json > inja::Renderer::eval_expression_list ( const ExpressionListNode & expression_list )

inlineprivate

Definition at line 2253 of file inja.hpp.

                                                                                                  {
            if (!expression_list.root) {
                throw_renderer_error("empty expression", expression_list);
            }
 
            expression_list.root->accept(*this);
 
            if (data_eval_stack.empty()) {
                throw_renderer_error("empty expression", expression_list);
            } else if (data_eval_stack.size() != 1) {
                throw_renderer_error("malformed expression", expression_list);
            }
 
            const auto result = data_eval_stack.top();
            data_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);
        }

References inja::ExpressionNode::accept(), data_eval_stack, inja::DataNode::name, not_found_stack, inja::ExpressionListNode::root, and throw_renderer_error().

Referenced by visit(), visit(), visit(), visit(), and visit().

Here is the call graph for this function:

Here is the caller graph for this function:

get_argument_vector()

template<bool throw_not_found = true>

Arguments inja::Renderer::get_argument_vector ( const FunctionNode & node )

inlineprivate

Definition at line 2329 of file inja.hpp.

                                                                {
            const size_t N = node.arguments.size();
            for (auto a : node.arguments) {
                a->accept(*this);
            }
 
            if (data_eval_stack.size() < N) {
                throw_renderer_error("function needs " + std::to_string(N) + " variables, but has only found " +
                                         std::to_string(data_eval_stack.size()),
                                     node);
            }
 
            Arguments result{N};
            for (size_t i = 0; i < N; i += 1) {
                result[N - i - 1] = data_eval_stack.top();
                data_eval_stack.pop();
 
                if (!result[N - i - 1]) {
                    const auto data_node = not_found_stack.top();
                    not_found_stack.pop();
 
                    if (throw_not_found) {
                        throw_renderer_error("variable '" + static_cast<std::string>(data_node->name) + "' not found", *data_node);
                    }
                }
            }
            return result;
        }

References inja::ExpressionNode::accept(), inja::FunctionNode::arguments, data_eval_stack, inja::DataNode::name, not_found_stack, and throw_renderer_error().

Here is the call graph for this function:

get_arguments()

template<size_t N, size_t N_start = 0, bool throw_not_found = true>

std::array< const json *, N > inja::Renderer::get_arguments ( const FunctionNode & node )

inlineprivate

Definition at line 2294 of file inja.hpp.

                                                                         {
            if (node.arguments.size() < N_start + N) {
                throw_renderer_error("function needs " + std::to_string(N_start + N) + " variables, but has only found " +
                                         std::to_string(node.arguments.size()),
                                     node);
            }
 
            for (size_t i = N_start; i < N_start + N; i += 1) {
                node.arguments[i]->accept(*this);
            }
 
            if (data_eval_stack.size() < N) {
                throw_renderer_error("function needs " + std::to_string(N) + " variables, but has only found " +
                                         std::to_string(data_eval_stack.size()),
                                     node);
            }
 
            std::array<const json*, N> result;
            for (size_t i = 0; i < N; i += 1) {
                result[N - i - 1] = data_eval_stack.top();
                data_eval_stack.pop();
 
                if (!result[N - i - 1]) {
                    const auto data_node = not_found_stack.top();
                    not_found_stack.pop();
 
                    if (throw_not_found) {
                        throw_renderer_error("variable '" + static_cast<std::string>(data_node->name) + "' not found", *data_node);
                    }
                }
            }
            return result;
        }

References inja::ExpressionNode::accept(), inja::FunctionNode::arguments, data_eval_stack, inja::DataNode::name, not_found_stack, and throw_renderer_error().

Here is the call graph for this function:

make_result()

void inja::Renderer::make_result ( const json && result )

inlineprivate

Definition at line 2287 of file inja.hpp.

                                              {
            auto result_ptr = std::make_shared<json>(result);
            data_tmp_stack.push_back(result_ptr);
            data_eval_stack.push(result_ptr.get());
        }

References data_eval_stack, and data_tmp_stack.

print_data()

void inja::Renderer::print_data ( const std::shared_ptr< json > value )

inlineprivate

Definition at line 2240 of file inja.hpp.

                                                         {
            if (value->is_string()) {
                *output_stream << value->get_ref<const json::string_t&>();
            } else if (value->is_number_unsigned()) {
                *output_stream << value->get<const json::number_unsigned_t>();
            } else if (value->is_number_integer()) {
                *output_stream << value->get<const json::number_integer_t>();
            } else if (value->is_null()) {
            } else {
                *output_stream << value->dump();
            }
        }

References output_stream.

render_to()

void inja::Renderer::render_to ( std::ostream & os, const Template & tmpl, const json & data, json * loop_data = nullptr )

inline

Definition at line 2822 of file inja.hpp.

                                                                                                          {
            output_stream = &os;
            current_template = &tmpl;
            data_input = &data;
            if (loop_data) {
                additional_data = *loop_data;
                current_loop_data = &additional_data["loop"];
            }
 
            template_stack.emplace_back(current_template);
            current_template->root.accept(*this);
 
            data_tmp_stack.clear();
        }

References inja::BlockNode::accept(), additional_data, current_loop_data, current_template, data_input, data_tmp_stack, output_stream, inja::Template::root, and template_stack.

Here is the call graph for this function:

throw_renderer_error()

void inja::Renderer::throw_renderer_error ( const std::string & message, const AstNode & node )

inlineprivate

Definition at line 2282 of file inja.hpp.

                                                                                              {
            SourceLocation loc = get_source_location(current_template->content, node.pos);
            INJA_THROW(RenderError(message, loc));
        }

References inja::Template::content, current_template, inja::get_source_location(), inja::AstNode::pos, and inja::RenderError::RenderError().

Referenced by eval_expression_list(), get_argument_vector(), get_arguments(), visit(), visit(), visit(), visit(), and visit().

Here is the call graph for this function:

Here is the caller graph for this function:

truthy()

bool inja::Renderer::truthy ( const json * data )

inlinestaticprivate

Definition at line 2229 of file inja.hpp.

                                             {
            if (data->is_boolean()) {
                return data->get<bool>();
            } else if (data->is_number()) {
                return (*data != 0);
            } else if (data->is_null()) {
                return false;
            }
            return !data->empty();
        }

visit() [1/16]

void inja::Renderer::visit ( const BlockNode & node )

inlineoverrideprivatevirtual

Implements inja::NodeVisitor.

Definition at line 2358 of file inja.hpp.

                                                   {
            for (auto& n : node.nodes) {
                n->accept(*this);
 
                if (break_rendering) {
                    break;
                }
            }
        }

References inja::AstNode::accept(), break_rendering, and inja::BlockNode::nodes.

Here is the call graph for this function:

visit() [2/16]

void inja::Renderer::visit ( const BlockStatementNode & node )

inlineoverrideprivatevirtual

Implements inja::NodeVisitor.

Definition at line 2794 of file inja.hpp.

                                                            {
            const size_t old_level = current_level;
            current_level = 0;
            current_template = template_stack.front();
            const auto block_it = current_template->block_storage.find(node.name);
            if (block_it != current_template->block_storage.end()) {
                block_statement_stack.emplace_back(&node);
                block_it->second->block.accept(*this);
                block_statement_stack.pop_back();
            }
            current_level = old_level;
            current_template = template_stack.back();
        }

References inja::BlockNode::accept(), inja::BlockStatementNode::block, block_statement_stack, inja::Template::block_storage, current_level, current_template, inja::BlockStatementNode::name, and template_stack.

Here is the call graph for this function:

visit() [3/16]

void inja::Renderer::visit ( const DataNode & node )

inlineoverrideprivatevirtual

Implements inja::NodeVisitor.

Definition at line 2379 of file inja.hpp.

                                                  {
            if (additional_data.contains(node.ptr)) {
                data_eval_stack.push(&(additional_data[node.ptr]));
            } else if (data_input->contains(node.ptr)) {
                data_eval_stack.push(&(*data_input)[node.ptr]);
            } else {
                // Try to evaluate as a no-argument callback
                const auto function_data = function_storage.find_function(node.name, 0);
                if (function_data.operation == FunctionStorage::Operation::Callback) {
                    Arguments empty_args{};
                    const auto value = std::make_shared<json>(function_data.callback(empty_args));
                    data_tmp_stack.push_back(value);
                    data_eval_stack.push(value.get());
                } else {
                    data_eval_stack.push(nullptr);
                    not_found_stack.emplace(&node);
                }
            }
        }

References additional_data, inja::FunctionStorage::Callback, inja::FunctionStorage::FunctionData::callback, data_eval_stack, data_input, data_tmp_stack, inja::FunctionStorage::find_function(), function_storage, inja::DataNode::name, not_found_stack, inja::FunctionStorage::FunctionData::operation, and inja::DataNode::ptr.

Here is the call graph for this function:

visit() [4/16]

void inja::Renderer::visit ( const ExpressionListNode & node )

inlineoverrideprivatevirtual

Implements inja::NodeVisitor.

Definition at line 2676 of file inja.hpp.

                                                            {
            print_data(eval_expression_list(node));
        }

References eval_expression_list().

Here is the call graph for this function:

visit() [5/16]

void inja::Renderer::visit ( const ExpressionNode & )

inlineoverrideprivatevirtual

Implements inja::NodeVisitor.

Definition at line 2372 of file inja.hpp.

                                                   {
        }

visit() [6/16]

void inja::Renderer::visit ( const ExtendsStatementNode & node )

inlineoverrideprivatevirtual

Implements inja::NodeVisitor.

Definition at line 2783 of file inja.hpp.

                                                              {
            const auto included_template_it = template_storage.find(node.file);
            if (included_template_it != template_storage.end()) {
                const Template* parent_template = &included_template_it->second;
                render_to(*output_stream, *parent_template, *data_input, &additional_data);
                break_rendering = true;
            } else if (config.throw_at_missing_includes) {
                throw_renderer_error("extends '" + node.file + "' not found", node);
            }
        }

References additional_data, break_rendering, config, data_input, inja::ExtendsStatementNode::file, output_stream, template_storage, inja::RenderConfig::throw_at_missing_includes, and throw_renderer_error().

Here is the call graph for this function:

visit() [7/16]

void inja::Renderer::visit ( const ForArrayStatementNode & node )

inlineoverrideprivatevirtual

Implements inja::NodeVisitor.

Definition at line 2686 of file inja.hpp.

                                                               {
            const 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);
            }
 
            size_t index = 0;
            (*current_loop_data)["is_first"] = true;
            (*current_loop_data)["is_last"] = (result->size() <= 1);
            for (auto it = result->begin(); it != result->end(); ++it) {
                additional_data[static_cast<std::string>(node.value)] = *it;
 
                (*current_loop_data)["index"] = index;
                (*current_loop_data)["index1"] = index + 1;
                if (index == 1) {
                    (*current_loop_data)["is_first"] = false;
                }
                if (index == result->size() - 1) {
                    (*current_loop_data)["is_last"] = true;
                }
 
                node.body.accept(*this);
                ++index;
            }
 
            additional_data[static_cast<std::string>(node.value)].clear();
            if (!(*current_loop_data)["parent"].empty()) {
                const auto tmp = (*current_loop_data)["parent"];
                *current_loop_data = std::move(tmp);
            } else {
                current_loop_data = &additional_data["loop"];
            }
        }

References inja::BlockNode::accept(), additional_data, inja::ForStatementNode::body, inja::ForStatementNode::condition, current_loop_data, eval_expression_list(), throw_renderer_error(), and inja::ForArrayStatementNode::value.

Here is the call graph for this function:

visit() [8/16]

void inja::Renderer::visit ( const ForObjectStatementNode & node )

inlineoverrideprivatevirtual

Implements inja::NodeVisitor.

Definition at line 2725 of file inja.hpp.

                                                                {
            const 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);
            }
 
            size_t index = 0;
            (*current_loop_data)["is_first"] = true;
            (*current_loop_data)["is_last"] = (result->size() <= 1);
            for (auto it = result->begin(); it != result->end(); ++it) {
                additional_data[static_cast<std::string>(node.key)] = it.key();
                additional_data[static_cast<std::string>(node.value)] = it.value();
 
                (*current_loop_data)["index"] = index;
                (*current_loop_data)["index1"] = index + 1;
                if (index == 1) {
                    (*current_loop_data)["is_first"] = false;
                }
                if (index == result->size() - 1) {
                    (*current_loop_data)["is_last"] = true;
                }
 
                node.body.accept(*this);
                ++index;
            }
 
            additional_data[static_cast<std::string>(node.key)].clear();
            additional_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 = &additional_data["loop"];
            }
        }

References inja::BlockNode::accept(), additional_data, inja::ForStatementNode::body, inja::ForStatementNode::condition, current_loop_data, eval_expression_list(), inja::ForObjectStatementNode::key, throw_renderer_error(), and inja::ForObjectStatementNode::value.

Here is the call graph for this function:

visit() [9/16]

void inja::Renderer::visit ( const ForStatementNode & )

inlineoverrideprivatevirtual

Implements inja::NodeVisitor.

Definition at line 2683 of file inja.hpp.

                                                     {
        }

visit() [10/16]

void inja::Renderer::visit ( const FunctionNode & node )

inlineoverrideprivatevirtual

Implements inja::NodeVisitor.

Definition at line 2399 of file inja.hpp.

                                                      {
            switch (node.operation) {
                case Op::Not: {
                    const auto args = get_arguments<1>(node);
                    make_result(!truthy(args[0]));
                } break;
                case Op::And: {
                    make_result(truthy(get_arguments<1, 0>(node)[0]) && truthy(get_arguments<1, 1>(node)[0]));
                } break;
                case Op::Or: {
                    make_result(truthy(get_arguments<1, 0>(node)[0]) || truthy(get_arguments<1, 1>(node)[0]));
                } break;
                case Op::In: {
                    const auto args = get_arguments<2>(node);
                    make_result(std::find(args[1]->begin(), args[1]->end(), *args[0]) != args[1]->end());
                } break;
                case Op::Equal: {
                    const auto args = get_arguments<2>(node);
                    make_result(*args[0] == *args[1]);
                } break;
                case Op::NotEqual: {
                    const auto args = get_arguments<2>(node);
                    make_result(*args[0] != *args[1]);
                } break;
                case Op::Greater: {
                    const auto args = get_arguments<2>(node);
                    make_result(*args[0] > *args[1]);
                } break;
                case Op::GreaterEqual: {
                    const auto args = get_arguments<2>(node);
                    make_result(*args[0] >= *args[1]);
                } break;
                case Op::Less: {
                    const auto args = get_arguments<2>(node);
                    make_result(*args[0] < *args[1]);
                } break;
                case Op::LessEqual: {
                    const auto args = get_arguments<2>(node);
                    make_result(*args[0] <= *args[1]);
                } break;
                case Op::Add: {
                    const auto args = get_arguments<2>(node);
                    if (args[0]->is_string() && args[1]->is_string()) {
                        make_result(args[0]->get_ref<const json::string_t&>() + args[1]->get_ref<const json::string_t&>());
                    } else if (args[0]->is_number_integer() && args[1]->is_number_integer()) {
                        make_result(args[0]->get<const json::number_integer_t>() + args[1]->get<const json::number_integer_t>());
                    } else {
                        make_result(args[0]->get<const json::number_float_t>() + args[1]->get<const json::number_float_t>());
                    }
                } break;
                case Op::Subtract: {
                    const auto args = get_arguments<2>(node);
                    if (args[0]->is_number_integer() && args[1]->is_number_integer()) {
                        make_result(args[0]->get<const json::number_integer_t>() - args[1]->get<const json::number_integer_t>());
                    } else {
                        make_result(args[0]->get<const json::number_float_t>() - args[1]->get<const json::number_float_t>());
                    }
                } break;
                case Op::Multiplication: {
                    const auto args = get_arguments<2>(node);
                    if (args[0]->is_number_integer() && args[1]->is_number_integer()) {
                        make_result(args[0]->get<const json::number_integer_t>() * args[1]->get<const json::number_integer_t>());
                    } else {
                        make_result(args[0]->get<const json::number_float_t>() * args[1]->get<const json::number_float_t>());
                    }
                } break;
                case Op::Division: {
                    const auto args = get_arguments<2>(node);
                    if (args[1]->get<const json::number_float_t>() == 0) {
                        throw_renderer_error("division by zero", node);
                    }
                    make_result(args[0]->get<const json::number_float_t>() / args[1]->get<const json::number_float_t>());
                } break;
                case Op::Power: {
                    const auto args = get_arguments<2>(node);
                    if (args[0]->is_number_integer() && args[1]->get<const json::number_integer_t>() >= 0) {
                        const auto result = static_cast<json::number_integer_t>(
                            std::pow(args[0]->get<const json::number_integer_t>(), args[1]->get<const json::number_integer_t>()));
                        make_result(result);
                    } else {
                        const auto result =
                            std::pow(args[0]->get<const json::number_float_t>(), args[1]->get<const json::number_integer_t>());
                        make_result(result);
                    }
                } break;
                case Op::Modulo: {
                    const auto args = get_arguments<2>(node);
                    make_result(args[0]->get<const json::number_integer_t>() % args[1]->get<const json::number_integer_t>());
                } break;
                case Op::AtId: {
                    const auto container = get_arguments<1, 0, false>(node)[0];
                    node.arguments[1]->accept(*this);
                    if (not_found_stack.empty()) {
                        throw_renderer_error("could not find element with given name", node);
                    }
                    const auto id_node = not_found_stack.top();
                    not_found_stack.pop();
                    data_eval_stack.pop();
                    data_eval_stack.push(&container->at(id_node->name));
                } break;
                case Op::At: {
                    const auto args = get_arguments<2>(node);
                    if (args[0]->is_object()) {
                        data_eval_stack.push(&args[0]->at(args[1]->get<std::string>()));
                    } else {
                        data_eval_stack.push(&args[0]->at(args[1]->get<std::stack<const json*>::size_type>()));
                    }
                } break;
                case Op::Default: {
                    const auto test_arg = get_arguments<1, 0, false>(node)[0];
                    data_eval_stack.push(test_arg ? test_arg : get_arguments<1, 1>(node)[0]);
                } break;
                case Op::DivisibleBy: {
                    const auto args = get_arguments<2>(node);
                    const auto divisor = args[1]->get<const json::number_integer_t>();
                    make_result((divisor != 0) && (args[0]->get<const json::number_integer_t>() % divisor == 0));
                } break;
                case Op::Even: {
                    make_result(get_arguments<1>(node)[0]->get<const json::number_integer_t>() % 2 == 0);
                } break;
                case Op::Exists: {
                    auto&& name = get_arguments<1>(node)[0]->get_ref<const json::string_t&>();
                    make_result(data_input->contains(json::json_pointer(DataNode::convert_dot_to_ptr(name))));
                } break;
                case Op::ExistsInObject: {
                    const auto args = get_arguments<2>(node);
                    auto&& name = args[1]->get_ref<const json::string_t&>();
                    make_result(args[0]->find(name) != args[0]->end());
                } break;
                case Op::First: {
                    const auto result = &get_arguments<1>(node)[0]->front();
                    data_eval_stack.push(result);
                } break;
                case Op::Float: {
                    make_result(std::stod(get_arguments<1>(node)[0]->get_ref<const json::string_t&>()));
                } break;
                case Op::Int: {
                    make_result(std::stoi(get_arguments<1>(node)[0]->get_ref<const json::string_t&>()));
                } break;
                case Op::Last: {
                    const auto result = &get_arguments<1>(node)[0]->back();
                    data_eval_stack.push(result);
                } break;
                case Op::Length: {
                    const auto val = get_arguments<1>(node)[0];
                    if (val->is_string()) {
                        make_result(val->get_ref<const json::string_t&>().length());
                    } else {
                        make_result(val->size());
                    }
                } break;
                case Op::Lower: {
                    auto result = get_arguments<1>(node)[0]->get<json::string_t>();
                    std::transform(result.begin(), result.end(), result.begin(), [](char c) {
                        return static_cast<char>(::tolower(c));
                    });
                    make_result(std::move(result));
                } break;
                case Op::Max: {
                    const auto args = get_arguments<1>(node);
                    const auto result = std::max_element(args[0]->begin(), args[0]->end());
                    data_eval_stack.push(&(*result));
                } break;
                case Op::Min: {
                    const auto args = get_arguments<1>(node);
                    const auto result = std::min_element(args[0]->begin(), args[0]->end());
                    data_eval_stack.push(&(*result));
                } break;
                case Op::Odd: {
                    make_result(get_arguments<1>(node)[0]->get<const json::number_integer_t>() % 2 != 0);
                } break;
                case Op::Range: {
                    std::vector<int> result(get_arguments<1>(node)[0]->get<std::vector<int>::size_type>());
                    std::iota(result.begin(), result.end(), 0);
                    make_result(std::move(result));
                } break;
                case Op::Round: {
                    const auto args = get_arguments<2>(node);
                    const int precision = args[1]->get<int>();
                    const double result =
                        std::round(args[0]->get<const json::number_float_t>() * std::pow(10.0, precision)) / std::pow(10.0, precision);
                    if (precision == 0) {
                        make_result(int(result));
                    } else {
                        make_result(result);
                    }
                } break;
                case Op::Sort: {
                    auto result_ptr = std::make_shared<json>(get_arguments<1>(node)[0]->get<std::vector<json>>());
                    std::sort(result_ptr->begin(), result_ptr->end());
                    data_tmp_stack.push_back(result_ptr);
                    data_eval_stack.push(result_ptr.get());
                } break;
                case Op::Upper: {
                    auto result = get_arguments<1>(node)[0]->get<json::string_t>();
                    std::transform(result.begin(), result.end(), result.begin(), [](char c) {
                        return static_cast<char>(::toupper(c));
                    });
                    make_result(std::move(result));
                } break;
                case Op::IsBoolean: {
                    make_result(get_arguments<1>(node)[0]->is_boolean());
                } break;
                case Op::IsNumber: {
                    make_result(get_arguments<1>(node)[0]->is_number());
                } break;
                case Op::IsInteger: {
                    make_result(get_arguments<1>(node)[0]->is_number_integer());
                } break;
                case Op::IsFloat: {
                    make_result(get_arguments<1>(node)[0]->is_number_float());
                } break;
                case Op::IsObject: {
                    make_result(get_arguments<1>(node)[0]->is_object());
                } break;
                case Op::IsArray: {
                    make_result(get_arguments<1>(node)[0]->is_array());
                } break;
                case Op::IsString: {
                    make_result(get_arguments<1>(node)[0]->is_string());
                } break;
                case Op::Callback: {
                    auto args = get_argument_vector(node);
                    make_result(node.callback(args));
                } break;
                case Op::Super: {
                    const auto args = get_argument_vector(node);
                    const size_t old_level = current_level;
                    const size_t level_diff = (args.size() == 1) ? args[0]->get<size_t>() : 1;
                    const size_t level = current_level + level_diff;
 
                    if (block_statement_stack.empty()) {
                        throw_renderer_error("super() call is not within a block", node);
                    }
 
                    if (level < 1 || level > template_stack.size() - 1) {
                        throw_renderer_error("level of super() call does not match parent templates (between 1 and " +
                                                 std::to_string(template_stack.size() - 1) + ")",
                                             node);
                    }
 
                    const auto current_block_statement = block_statement_stack.back();
                    const Template* new_template = template_stack.at(level);
                    const Template* old_template = current_template;
                    const auto block_it = new_template->block_storage.find(current_block_statement->name);
                    if (block_it != new_template->block_storage.end()) {
                        current_template = new_template;
                        current_level = level;
                        block_it->second->block.accept(*this);
                        current_level = old_level;
                        current_template = old_template;
                    } else {
                        throw_renderer_error("could not find block with name '" + current_block_statement->name + "'", node);
                    }
                    make_result(nullptr);
                } break;
                case Op::Join: {
                    const auto args = get_arguments<2>(node);
                    const auto separator = args[1]->get<json::string_t>();
                    std::ostringstream os;
                    std::string sep;
                    for (const auto& value : *args[0]) {
                        os << sep;
                        if (value.is_string()) {
                            os << value.get<std::string>(); // otherwise the value is surrounded with ""
                        } else {
                            os << value.dump();
                        }
                        sep = separator;
                    }
                    make_result(os.str());
                } break;
                case Op::None:
                    break;
            }
        }

References inja::BlockNode::accept(), inja::ExpressionNode::accept(), inja::FunctionStorage::Add, inja::FunctionStorage::And, inja::FunctionNode::arguments, inja::FunctionStorage::At, inja::FunctionStorage::AtId, inja::BlockStatementNode::block, block_statement_stack, inja::Template::block_storage, inja::FunctionStorage::Callback, inja::FunctionNode::callback, inja::DataNode::convert_dot_to_ptr(), current_level, current_template, data_eval_stack, data_input, data_tmp_stack, inja::FunctionStorage::Default, inja::FunctionStorage::DivisibleBy, inja::FunctionStorage::Division, inja::FunctionStorage::Equal, inja::FunctionStorage::Even, inja::FunctionStorage::Exists, inja::FunctionStorage::ExistsInObject, inja::FunctionStorage::First, inja::FunctionStorage::Float, inja::FunctionStorage::Greater, inja::FunctionStorage::GreaterEqual, inja::FunctionStorage::In, inja::FunctionStorage::Int, inja::FunctionStorage::IsArray, inja::FunctionStorage::IsBoolean, inja::FunctionStorage::IsFloat, inja::FunctionStorage::IsInteger, inja::FunctionStorage::IsNumber, inja::FunctionStorage::IsObject, inja::FunctionStorage::IsString, inja::FunctionStorage::Join, inja::FunctionStorage::Last, inja::FunctionStorage::Length, inja::FunctionStorage::Less, inja::FunctionStorage::LessEqual, inja::FunctionStorage::Lower, inja::FunctionStorage::Max, inja::FunctionStorage::Min, inja::FunctionStorage::Modulo, inja::FunctionStorage::Multiplication, inja::BlockStatementNode::name, inja::DataNode::name, inja::FunctionStorage::None, inja::FunctionStorage::Not, not_found_stack, inja::FunctionStorage::NotEqual, inja::FunctionStorage::Odd, inja::FunctionNode::operation, inja::FunctionStorage::Or, inja::FunctionStorage::Power, inja::FunctionStorage::Range, inja::FunctionStorage::Round, inja::FunctionStorage::Sort, inja::FunctionStorage::Subtract, inja::FunctionStorage::Super, template_stack, throw_renderer_error(), and inja::FunctionStorage::Upper.

Here is the call graph for this function:

visit() [11/16]

void inja::Renderer::visit ( const IfStatementNode & node )

inlineoverrideprivatevirtual

Implements inja::NodeVisitor.

Definition at line 2764 of file inja.hpp.

                                                         {
            const 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);
            }
        }

References inja::BlockNode::accept(), inja::IfStatementNode::condition, eval_expression_list(), inja::IfStatementNode::false_statement, inja::IfStatementNode::has_false_statement, and inja::IfStatementNode::true_statement.

Here is the call graph for this function:

visit() [12/16]

void inja::Renderer::visit ( const IncludeStatementNode & node )

inlineoverrideprivatevirtual

Implements inja::NodeVisitor.

Definition at line 2773 of file inja.hpp.

                                                              {
            auto sub_renderer = Renderer(config, template_storage, function_storage);
            const 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, *data_input, &additional_data);
            } else if (config.throw_at_missing_includes) {
                throw_renderer_error("include '" + node.file + "' not found", node);
            }
        }

References additional_data, config, data_input, inja::IncludeStatementNode::file, function_storage, output_stream, template_storage, inja::RenderConfig::throw_at_missing_includes, and throw_renderer_error().

Here is the call graph for this function:

visit() [13/16]

void inja::Renderer::visit ( const LiteralNode & node )

inlineoverrideprivatevirtual

Implements inja::NodeVisitor.

Definition at line 2375 of file inja.hpp.

                                                     {
            data_eval_stack.push(&node.value);
        }

References data_eval_stack, and inja::LiteralNode::value.

visit() [14/16]

void inja::Renderer::visit ( const SetStatementNode & node )

inlineoverrideprivatevirtual

Implements inja::NodeVisitor.

Definition at line 2808 of file inja.hpp.

                                                          {
            std::string ptr = node.key;
            replace_substring(ptr, ".", "/");
            ptr = "/" + ptr;
            additional_data[json::json_pointer(ptr)] = *eval_expression_list(node.expression);
        }

References additional_data, eval_expression_list(), inja::SetStatementNode::expression, inja::SetStatementNode::key, and inja::replace_substring().

Here is the call graph for this function:

visit() [15/16]

void inja::Renderer::visit ( const StatementNode & )

inlineoverrideprivatevirtual

Implements inja::NodeVisitor.

Definition at line 2680 of file inja.hpp.

                                                  {
        }

visit() [16/16]

void inja::Renderer::visit ( const TextNode & node )

inlineoverrideprivatevirtual

Implements inja::NodeVisitor.

Definition at line 2368 of file inja.hpp.

                                                  {
            output_stream->write(current_template->content.c_str() + node.pos, static_cast<std::streamsize>(node.length));
        }

References inja::Template::content, current_template, inja::TextNode::length, output_stream, and inja::AstNode::pos.

Member Data Documentation

additional_data

json inja::Renderer::additional_data

private

Definition at line 2220 of file inja.hpp.

Referenced by render_to(), visit(), visit(), visit(), visit(), visit(), and visit().

block_statement_stack

std::vector<const BlockStatementNode*> inja::Renderer::block_statement_stack

private

Definition at line 2215 of file inja.hpp.

Referenced by visit(), and visit().

break_rendering

bool inja::Renderer::break_rendering {false}

private

Definition at line 2227 of file inja.hpp.

{false};

Referenced by visit(), and visit().

config

const RenderConfig inja::Renderer::config

private

Definition at line 2208 of file inja.hpp.

Referenced by Renderer(), visit(), and visit().

current_level

size_t inja::Renderer::current_level {0}

private

Definition at line 2213 of file inja.hpp.

{0};

Referenced by visit(), and visit().

current_loop_data

json* inja::Renderer::current_loop_data = &additional_data["loop"]

private

Definition at line 2221 of file inja.hpp.

Referenced by render_to(), visit(), and visit().

current_template

const Template* inja::Renderer::current_template

private

Definition at line 2212 of file inja.hpp.

Referenced by render_to(), throw_renderer_error(), visit(), visit(), and visit().

data_eval_stack

std::stack<const json*> inja::Renderer::data_eval_stack

private

Definition at line 2224 of file inja.hpp.

Referenced by eval_expression_list(), get_argument_vector(), get_arguments(), make_result(), visit(), visit(), and visit().

data_input

const json* inja::Renderer::data_input

private

Definition at line 2217 of file inja.hpp.

Referenced by render_to(), visit(), visit(), visit(), and visit().

data_tmp_stack

std::vector<std::shared_ptr<json> > inja::Renderer::data_tmp_stack

private

Definition at line 2223 of file inja.hpp.

Referenced by make_result(), render_to(), visit(), and visit().

function_storage

const FunctionStorage& inja::Renderer::function_storage

private

Definition at line 2210 of file inja.hpp.

Referenced by Renderer(), visit(), and visit().

not_found_stack

std::stack<const DataNode*> inja::Renderer::not_found_stack

private

Definition at line 2225 of file inja.hpp.

Referenced by eval_expression_list(), get_argument_vector(), get_arguments(), visit(), and visit().

output_stream

std::ostream* inja::Renderer::output_stream

private

Definition at line 2218 of file inja.hpp.

Referenced by print_data(), render_to(), visit(), visit(), and visit().

template_stack

std::vector<const Template*> inja::Renderer::template_stack

private

Definition at line 2214 of file inja.hpp.

Referenced by render_to(), visit(), and visit().

template_storage

const TemplateStorage& inja::Renderer::template_storage

private

Definition at line 2209 of file inja.hpp.

Referenced by Renderer(), visit(), and visit().

---

The documentation for this class was generated from the following file:

• lib/inja.hpp