clanguml::common::generators::detail Namespace Reference

Functions
template<typename DiagramConfig , typename GeneratorTag , typename DiagramModel >
void	generate_diagram_select_generator (const std::string &od, const std::string &name, std::shared_ptr< clanguml::config::diagram > diagram, const DiagramModel &model)
template<typename DiagramConfig >
void	generate_diagram_impl (const std::string &name, std::shared_ptr< clanguml::config::diagram > diagram, const common::compilation_database &db, const std::vector< std::string > &translation_units, const cli::runtime_config &runtime_config, std::function< void()> &&progress)

Function Documentation

generate_diagram_impl()

template<typename DiagramConfig >

void clanguml::common::generators::detail::generate_diagram_impl	(	const std::string &	name,
		std::shared_ptr< clanguml::config::diagram >	diagram,
		const common::compilation_database &	db,
		const std::vector< std::string > &	translation_units,
		const cli::runtime_config &	runtime_config,
		std::function< void()> &&	progress
	)

Definition at line 122 of file generators.cc.

{
    using diagram_config = DiagramConfig;
    using diagram_model = typename diagram_model_t<DiagramConfig>::type;
    using diagram_visitor = typename diagram_visitor_t<DiagramConfig>::type;
 
    auto model = clanguml::common::generators::generate<diagram_model,
        diagram_config, diagram_visitor>(db, diagram->name,
        dynamic_cast<diagram_config &>(*diagram), translation_units,
        runtime_config.verbose, std::move(progress));
 
    if constexpr (std::is_same_v<DiagramConfig, config::sequence_diagram>) {
        if (runtime_config.print_from) {
            auto from_values = model->list_from_values();
 
            for (const auto &from : from_values) {
                std::cout << from << '\n';
            }
 
            return;
        }
        if (runtime_config.print_to) {
            auto to_values = model->list_to_values();
 
            for (const auto &to : to_values) {
                std::cout << "|" << to << "|" << '\n';
            }
 
            return;
        }
    }
 
    for (const auto generator_type : runtime_config.generators) {
        if (generator_type == generator_type_t::plantuml) {
            generate_diagram_select_generator<diagram_config,
                plantuml_generator_tag>(
                runtime_config.output_directory, name, diagram, model);
        }
        else if (generator_type == generator_type_t::json) {
            generate_diagram_select_generator<diagram_config,
                json_generator_tag>(
                runtime_config.output_directory, name, diagram, model);
        }
        else if (generator_type == generator_type_t::mermaid) {
            generate_diagram_select_generator<diagram_config,
                mermaid_generator_tag>(
                runtime_config.output_directory, name, diagram, model);
        }
 
        // Convert plantuml or mermaid to an image using command provided
        // in the command line arguments
        if (runtime_config.render_diagrams) {
            render_diagram(generator_type, diagram);
        }
    }
}

generate_diagram_select_generator()

template<typename DiagramConfig , typename GeneratorTag , typename DiagramModel >

void clanguml::common::generators::detail::generate_diagram_select_generator	(	const std::string &	od,
		const std::string &	name,
		std::shared_ptr< clanguml::config::diagram >	diagram,
		const DiagramModel &	model
	)

Definition at line 97 of file generators.cc.

{
    using diagram_generator =
        typename diagram_generator_t<DiagramConfig, GeneratorTag>::type;
 
    std::stringstream buffer;
    buffer << diagram_generator(
        dynamic_cast<DiagramConfig &>(*diagram), *model);
 
    // Only open the file after the diagram has been generated successfully
    // in order not to overwrite previous diagram in case of failure
    auto path = std::filesystem::path{od} /
        fmt::format("{}.{}", name, GeneratorTag::extension);
    std::ofstream ofs;
    ofs.open(path, std::ofstream::out | std::ofstream::trunc);
    ofs << buffer.str();
 
    ofs.close();
 
    LOG_INFO("Written {} diagram to {}", name, path.string());
}