clanguml::common::generators Namespace Reference

Namespaces
namespace	detail
namespace	json
namespace	mermaid
namespace	plantuml

Classes
class	diagram_action_visitor_factory
	Specialization of clang::ASTFrontendAction More...
class	diagram_ast_consumer
	Specialization of clang::ASTConsumer More...
class	diagram_fronted_action
	Specialization of clang::ASTFrontendAction More...
struct	diagram_generator_t
struct	diagram_generator_t< clanguml::config::class_diagram, json_generator_tag >
struct	diagram_generator_t< clanguml::config::class_diagram, mermaid_generator_tag >
struct	diagram_generator_t< clanguml::config::class_diagram, plantuml_generator_tag >
struct	diagram_generator_t< clanguml::config::include_diagram, json_generator_tag >
struct	diagram_generator_t< clanguml::config::include_diagram, mermaid_generator_tag >
struct	diagram_generator_t< clanguml::config::include_diagram, plantuml_generator_tag >
struct	diagram_generator_t< clanguml::config::package_diagram, json_generator_tag >
struct	diagram_generator_t< clanguml::config::package_diagram, mermaid_generator_tag >
struct	diagram_generator_t< clanguml::config::package_diagram, plantuml_generator_tag >
struct	diagram_generator_t< clanguml::config::sequence_diagram, json_generator_tag >
struct	diagram_generator_t< clanguml::config::sequence_diagram, mermaid_generator_tag >
struct	diagram_generator_t< clanguml::config::sequence_diagram, plantuml_generator_tag >
struct	diagram_model_t
struct	diagram_model_t< clanguml::config::class_diagram >
struct	diagram_model_t< clanguml::config::include_diagram >
struct	diagram_model_t< clanguml::config::package_diagram >
struct	diagram_model_t< clanguml::config::sequence_diagram >
struct	diagram_visitor_t
struct	diagram_visitor_t< clanguml::config::class_diagram >
struct	diagram_visitor_t< clanguml::config::include_diagram >
struct	diagram_visitor_t< clanguml::config::package_diagram >
struct	diagram_visitor_t< clanguml::config::sequence_diagram >
class	generator
	Common diagram generator interface. More...
struct	json_generator_tag
struct	mermaid_generator_tag
class	nested_element_stack
struct	plantuml_generator_tag
class	progress_indicator
	Container for diagram generation progress indicators. More...

Functions
void	make_context_source_relative (inja::json &context, const std::string &prefix)
void	find_translation_units_for_diagrams (const std::vector< std::string > &diagram_names, clanguml::config::config &config, const std::vector< std::string > &compilation_database_files, std::map< std::string, std::vector< std::string > > &translation_units_map)
	Assign translation units to diagrams.
void	render_diagram (const clanguml::common::generator_type_t generator_type, std::shared_ptr< config::diagram > diagram_config)
void	generate_diagram (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)
	Generate a single diagram.
void	generate_diagrams (const std::vector< std::string > &diagram_names, clanguml::config::config &config, const common::compilation_database_ptr &db, const cli::runtime_config &runtime_config, const std::map< std::string, std::vector< std::string > > &translation_units_map)
	Generate diagrams.
indicators::Color	diagram_type_to_color (model::diagram_t diagram_type)
	Return indicators progress bar color for diagram type.
template<typename DiagramModel , typename DiagramConfig , typename DiagramVisitor >
std::unique_ptr< DiagramModel >	generate (const common::compilation_database &db, const std::string &name, DiagramConfig &config, const std::vector< std::string > &translation_units, bool=false, std::function< void()> progress={})
	Specialization of clang::ASTFrontendAction

Function Documentation

diagram_type_to_color()

indicators::Color clanguml::common::generators::diagram_type_to_color

(

model::diagram_t

diagram_type

)

Return indicators progress bar color for diagram type.

Parameters

diagram_type

Diagram type

Returns

Progress bar color

Definition at line 307 of file generators.cc.

{
    switch (diagram_type) {
    case model::diagram_t::kClass:
        return indicators::Color::yellow;
    case model::diagram_t::kSequence:
        return indicators::Color::blue;
    case model::diagram_t::kPackage:
        return indicators::Color::cyan;
    case model::diagram_t::kInclude:
        return indicators::Color::magenta;
    default:
        return indicators::Color::unspecified;
    }
}

find_translation_units_for_diagrams()

void clanguml::common::generators::find_translation_units_for_diagrams	(	const std::vector< std::string > &	diagram_names,
		clanguml::config::config &	config,
		const std::vector< std::string > &	compilation_database_files,
		std::map< std::string, std::vector< std::string > > &	translation_units_map
	)

Assign translation units to diagrams.

This function assigns for each diagram to be generated the list of translation units based on it's glob pattern if any.

If diagram_names is empty, this function processes all diagrams in config.

Parameters

diagram_names	List of diagram names, applies to all if empty
config	Reference to config instance
compilation_database_files	List of files found in compilation database
translation_units_map	Resulting translation units map is stored here

Definition at line 46 of file generators.cc.

{
    for (const auto &[name, diagram] : config.diagrams) {
        // If there are any specific diagram names provided on the command line,
        // and this diagram is not in that list - skip it
        if (!diagram_names.empty() && !util::contains(diagram_names, name))
            continue;
 
        translation_units_map[name] =
            diagram->glob_translation_units(compilation_database_files);
 
        LOG_DBG("Found {} translation units for diagram {}",
            translation_units_map.at(name).size(), name);
    }
}

generate()

template<typename DiagramModel , typename DiagramConfig , typename DiagramVisitor >

std::unique_ptr< DiagramModel > clanguml::common::generators::generate	(	const common::compilation_database &	db,
		const std::string &	name,
		DiagramConfig &	config,
		const std::vector< std::string > &	translation_units,
		bool	= false,
		std::function< void()>	progress = {}
	)

Specialization of clang::ASTFrontendAction

This is the entry point function to initiate AST frontend action for a specific diagram.

Template Parameters

DiagramModel	Type of diagram_model
DiagramConfig	Type of diagram_config
TranslationUnitVisitor	Type of translation_unit_visitor

Definition at line 362 of file generators.h.

                                   {})
{
    LOG_INFO("Generating diagram {}", name);
 
    auto diagram = std::make_unique<DiagramModel>();
    diagram->set_name(name);
    diagram->set_filter(
        model::diagram_filter_factory::create(*diagram, config));
 
    LOG_DBG("Found translation units for diagram {}: {}", name,
        fmt::join(translation_units, ", "));
 
    clang::tooling::ClangTool clang_tool(db, translation_units);
    auto action_factory =
        std::make_unique<diagram_action_visitor_factory<DiagramModel,
            DiagramConfig, DiagramVisitor>>(
            *diagram, config, std::move(progress));
 
    auto res = clang_tool.run(action_factory.get());
 
    if (res != 0) {
        throw std::runtime_error("Diagram " + name + " generation failed");
    }
 
    diagram->set_complete(true);
 
    diagram->finalize();
 
    return diagram;
}

generate_diagram()

void clanguml::common::generators::generate_diagram	(	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
	)

Generate a single diagram.

Parameters

name	Name of the diagram
diagram	Effective diagram configuration
db	Reference to compilation database
translation_units	List of translation units for the diagram
generators	List of generator types to be used for the diagram
verbose	Log level
progress	Function to report translation unit progress

Definition at line 184 of file generators.cc.

{
    using clanguml::common::generator_type_t;
    using clanguml::common::model::diagram_t;
 
    using clanguml::config::class_diagram;
    using clanguml::config::include_diagram;
    using clanguml::config::package_diagram;
    using clanguml::config::sequence_diagram;
 
    if (diagram->type() == diagram_t::kClass) {
        detail::generate_diagram_impl<class_diagram>(name, diagram, db,
            translation_units, runtime_config, std::move(progress));
    }
    else if (diagram->type() == diagram_t::kSequence) {
        detail::generate_diagram_impl<sequence_diagram>(name, diagram, db,
            translation_units, runtime_config, std::move(progress));
    }
    else if (diagram->type() == diagram_t::kPackage) {
        detail::generate_diagram_impl<package_diagram>(name, diagram, db,
            translation_units, runtime_config, std::move(progress));
    }
    else if (diagram->type() == diagram_t::kInclude) {
        detail::generate_diagram_impl<include_diagram>(name, diagram, db,
            translation_units, runtime_config, std::move(progress));
    }
}

generate_diagrams()

void clanguml::common::generators::generate_diagrams	(	const std::vector< std::string > &	diagram_names,
		clanguml::config::config &	config,
		const common::compilation_database_ptr &	db,
		const cli::runtime_config &	runtime_config,
		const std::map< std::string, std::vector< std::string > > &	translation_units_map
	)

Generate diagrams.

Parameters

diagram_names	List of diagram names to generate
config	Reference to config instance
output_directory	Path to output directory
db	Reference to compilation database
verbose	Log level
thread_count	Number of diagrams to be generated in parallel
progress	Whether progress indicators should be displayed
generators	List of generator types to use for each diagram
translation_units_map	Map of translation units for each file

Definition at line 216 of file generators.cc.

{
    util::thread_pool_executor generator_executor{runtime_config.thread_count};
    std::vector<std::future<void>> futs;
 
    std::unique_ptr<progress_indicator> indicator;
 
    if (runtime_config.progress) {
        std::cout << termcolor::white
                  << "Processing translation units and generating diagrams:\n";
        indicator = std::make_unique<progress_indicator>();
    }
 
    for (const auto &[name, diagram] : config.diagrams) {
        // If there are any specific diagram names provided on the command
        // line, and this diagram is not in that list - skip it
        if (!diagram_names.empty() && !util::contains(diagram_names, name))
            continue;
 
        const auto &valid_translation_units = translation_units_map.at(name);
 
        LOG_DBG("Found {} valid translation units for diagram {}",
            valid_translation_units.size(), name);
 
        const auto matching_commands_count =
            db->count_matching_commands(valid_translation_units);
 
        if (matching_commands_count == 0) {
            if (indicator) {
                indicator->add_progress_bar(
                    name, 0, diagram_type_to_color(diagram->type()));
                indicator->fail(name);
            }
            else {
                LOG_ERROR(
                    "Diagram {} generation failed: no translation units "
                    "found. Please make sure that your 'glob' patterns match "
                    "at least 1 file in 'compile_commands.json'.",
                    name);
            }
            continue;
        }
 
        LOG_DBG("Found {} matching translation unit commands for diagram {}",
            matching_commands_count, name);
 
        auto generator = [&name = name, &diagram = diagram, &indicator,
                             db = std::ref(*db), matching_commands_count,
                             translation_units = valid_translation_units,
                             runtime_config]() mutable {
            try {
                if (indicator)
                    indicator->add_progress_bar(name, matching_commands_count,
                        diagram_type_to_color(diagram->type()));
 
                generate_diagram(name, diagram, db, translation_units,
                    runtime_config, [&indicator, &name]() {
                        if (indicator)
                            indicator->increment(name);
                    });
 
                if (indicator)
                    indicator->complete(name);
            }
            catch (const std::exception &e) {
                if (indicator)
                    indicator->fail(name);
 
                LOG_ERROR(
                    "ERROR: Failed to generate diagram {}: {}", name, e.what());
            }
        };
 
        futs.emplace_back(generator_executor.add(std::move(generator)));
    }
 
    for (auto &fut : futs) {
        fut.get();
    }
 
    if (runtime_config.progress) {
        indicator->stop();
        std::cout << termcolor::white << "Done\n";
        std::cout << termcolor::reset;
    }
}

make_context_source_relative()

void clanguml::common::generators::make_context_source_relative	(	inja::json &	context,
		const std::string &	prefix
	)

Definition at line 24 of file generators.cc.

{
    if (!context.contains("element"))
        return;
 
    if (!context["element"].contains("source"))
        return;
 
    auto &source = context["element"]["source"];
 
    if (source.at("path").empty())
        return;
 
    auto path = std::filesystem::path{source.at("path")};
    auto prefix_path = std::filesystem::path(prefix);
    if (path.is_absolute() && util::is_relative_to(path, prefix_path)) {
        source["path"] = relative(path, prefix_path);
        return;
    }
}

render_diagram()

void clanguml::common::generators::render_diagram	(	const clanguml::common::generator_type_t	generator_type,
		std::shared_ptr< config::diagram >	diagram_config
	)

Definition at line 66 of file generators.cc.

{
    std::string cmd;
    switch (generator_type) {
    case clanguml::common::generator_type_t::plantuml:
        cmd = diagram_config->puml().cmd;
        break;
    case clanguml::common::generator_type_t::mermaid:
        cmd = diagram_config->mermaid().cmd;
        break;
    default:
        return;
    };
 
    if (cmd.empty())
        throw std::runtime_error(
            fmt::format("No render command template provided for {} diagrams",
                to_string(diagram_config->type())));
 
    util::replace_all(cmd, "{}", diagram_config->name);
 
    LOG_INFO("Rendering diagram {} using {}", diagram_config->name,
        to_string(generator_type));
 
    util::check_process_output(cmd);
}