clanguml::common::generators Namespace Reference

Namespaces
namespace	detail
namespace	graphml
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, graphml_generator_tag >
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, graphml_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, graphml_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, graphml_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	display_name_adapter
class	generator
	Common diagram generator interface. More...
struct	graphml_generator_tag
struct	json_generator_tag
class	json_logger_progress_indicator
struct	mermaid_generator_tag
class	nested_element_stack
struct	not_supported
struct	plantuml_generator_tag
class	progress_indicator
	Container for diagram generation progress indicators. More...
class	progress_indicator_base

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 compilation_database &compilation_database, 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.
int	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 GeneratorTag >
constexpr bool	generator_supports_diagram_type (clanguml::common::model::diagram_t dt)
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 456 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 compilation_database &	compilation_database,
		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	Reference to a 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.getAllFiles(),
                compilation_database.is_fixed());
 
        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 419 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, ", "));
 
    const bool quiet_clang_tool = !!progress;
 
    clanguml::generators::clang_tool clang_tool(diagram->type(), name, db,
        translation_units, config.get_relative_to()(), quiet_clang_tool);
 
    auto action_factory =
        std::make_unique<diagram_action_visitor_factory<DiagramModel,
            DiagramConfig, DiagramVisitor>>(
            *diagram, config, std::move(progress));
 
    clang_tool.run(action_factory.get());
 
    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 213 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()

int 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

Returns

0 if success, otherwise error code

Definition at line 245 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_base> indicator;
 
    if (runtime_config.progress) {
        if (clanguml::logging::logger_type() == logging::logger_type_t::text) {
            std::cout
                << termcolor::white
                << "Processing translation units and generating diagrams:\n";
            indicator = std::make_unique<progress_indicator>();
        }
        else {
            indicator = std::make_unique<json_logger_progress_indicator>();
        }
    }
 
    std::vector<std::exception_ptr> errors;
 
    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;
 
        // If none of the generators supports the diagram type - skip it
        bool at_least_one_generator_supports_diagram_type{false};
        for (const auto generator_type : runtime_config.generators) {
            if (generator_type == generator_type_t::plantuml) {
                if (generator_supports_diagram_type<plantuml_generator_tag>(
                        diagram->type()))
                    at_least_one_generator_supports_diagram_type = true;
            }
            else if (generator_type == generator_type_t::json) {
                if (generator_supports_diagram_type<json_generator_tag>(
                        diagram->type()))
                    at_least_one_generator_supports_diagram_type = true;
            }
            else if (generator_type == generator_type_t::mermaid) {
                if (generator_supports_diagram_type<mermaid_generator_tag>(
                        diagram->type()))
                    at_least_one_generator_supports_diagram_type = true;
            }
            else if (generator_type == generator_type_t::graphml) {
                if (generator_supports_diagram_type<graphml_generator_tag>(
                        diagram->type()))
                    at_least_one_generator_supports_diagram_type = true;
            }
        }
 
        if (!at_least_one_generator_supports_diagram_type) {
            LOG_INFO("Diagram '{}' not supported by any of selected "
                     "generators - skipping...",
                name);
            continue;
        }
 
        const auto &valid_translation_units = translation_units_map.at(name);
 
        LOG_DBG("Found {} possible 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) {
            const auto error_msg = fmt::format(
                "Diagram '{}' generation failed: no translation units "
                "found. Please make sure that your 'glob' patterns match "
                "at least 1 file in 'compile_commands.json'.",
                name);
 
            if (indicator) {
                indicator->add_progress_bar(
                    name, 0, diagram_type_to_color(diagram->type()));
                indicator->fail(name);
                try {
                    throw std::runtime_error(error_msg);
                }
                catch (std::runtime_error &e) {
                    errors.emplace_back(std::current_exception());
                }
            }
            else {
                LOG_ERROR(error_msg);
            }
 
            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 -> void {
            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);
                }
                else {
                    generate_diagram(name, diagram, db, translation_units,
                        runtime_config, {});
                }
            }
            catch (clanguml::generators::clang_tool_exception &e) {
                if (indicator)
                    indicator->fail(name);
                throw std::move(e);
            }
            catch (std::exception &e) {
                if (indicator)
                    indicator->fail(name);
 
                LOG_ERROR(
                    "Failed to generate diagram '{}': {}", name, e.what());
 
                throw std::runtime_error(fmt::format(
                    "Failed to generate diagram '{}': {}", name, e.what()));
            }
        };
 
        futs.emplace_back(generator_executor.add(std::move(generator)));
    }
 
    for (auto &fut : futs) {
        try {
            fut.get();
        }
        catch (std::exception &e) {
            errors.emplace_back(std::current_exception());
        }
    }
 
    if (runtime_config.progress &&
        clanguml::logging::logger_type() == logging::logger_type_t::text) {
        indicator->stop();
        if (errors.empty()) {
            std::cout << termcolor::white << "Done\n";
        }
        else {
            std::cout << termcolor::white << "\n";
        }
        std::cout << termcolor::reset;
    }
 
    if (errors.empty())
        return 0;
 
    for (auto &e : errors) {
        try {
            std::rethrow_exception(e);
        }
        catch (const clanguml::generators::clang_tool_exception &e) {
            if (clanguml::logging::logger_type() ==
                logging::logger_type_t::text) {
 
                fmt::println("ERROR: Failed to generate {} diagram '{}' due to "
                             "following issues:",
                    e.diagram_type(), e.diagram_name());
                for (const auto &d : e.diagnostics) {
                    fmt::println(" - {}", d);
                }
                fmt::println("");
            }
            else {
                inja::json j;
                j["diagram_name"] = e.diagram_name();
                j["clang_errors"] = inja::json::array();
                for (const auto &d : e.diagnostics) {
                    j["clang_errors"].emplace_back(d);
                }
 
                spdlog::get("clanguml-logger")
                    ->log(spdlog::level::err,
                        fmt::runtime(
                            R"("file": "{}", "line": {}, "message": {})"),
                        FILENAME_, __LINE__, j.dump());
            }
        }
        catch (const std::exception &e) {
            if (clanguml::logging::logger_type() ==
                logging::logger_type_t::text) {
                fmt::println("ERROR: {}", e.what());
            }
            else {
                LOG_ERROR("{}", e.what());
            }
        }
    }
 
    return 1;
}

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").get<std::string>()};
    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 67 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);
}