Base class for diagram generators. More...

Detailed Description

template<typename ConfigType, typename DiagramType>
class clanguml::common::generators::mermaid::generator< ConfigType, DiagramType >

Base class for diagram generators.

Template Parameters

ConfigType	Configuration type
DiagramType	Diagram model type

Definition at line 57 of file generator.h.

#include <generator.h>

Public Member Functions
	generator (ConfigType &config, DiagramType &model)
	Constructor.

	~generator () override=default

void	generate (std::ostream &ostr) const override
	Generate diagram.

virtual void	generate_diagram (std::ostream &ostr) const =0
	Generate diagram specific part.

void	generate_mermaid_directives (std::ostream &ostr, const std::vector< std::string > &directives) const
	Generate MermaidJS directives from config file.

virtual void	generate_diagram_type (std::ostream &ostr) const =0
	Generate the diagram type.

virtual void	generate_notes (std::ostream &ostr, const model::diagram_element &element) const
	Generate diagram notes.

void	generate_metadata (std::ostream &ostr) const
	Generate comment with diagram metadata.

void	generate_title (std::ostream &ostr) const
	Generate diagram title.

template<typename E >
void	generate_link (std::ostream &ostr, const E &e) const
	Generate hyper link to element.

void	print_debug (const common::model::source_location &e, std::ostream &ostr) const
	Print debug information in diagram comments.

Public Member Functions inherited from clanguml::common::generators::generator< ConfigType, DiagramType >
	generator (ConfigType &config, DiagramType &model)
	Constructor.

virtual	~generator ()=default

virtual void	generate (std::ostream &ostr) const =0
	Generate diagram.

const ConfigType &	config () const
	Get reference to diagram config.

const DiagramType &	model () const
	Get reference to diagram model.

template<typename E >
inja::json	element_context (const E &e) const

std::optional< std::pair< std::string, std::string > >	get_link_pattern (const common::model::source_location &sl) const

std::optional< std::pair< std::string, std::string > >	get_tooltip_pattern (const common::model::source_location &sl) const

void	init_context ()
	Initialize diagram Jinja context.

void	update_context () const
	Update diagram Jinja context.

void	init_env ()

const inja::json &	context () const

inja::Environment &	env () const

Protected Attributes
std::set< std::string >	m_generated_aliases

Protected Attributes inherited from clanguml::common::generators::generator< ConfigType, DiagramType >
inja::json	m_context

inja::Environment	m_env

Constructor & Destructor Documentation

◆ generator()

template<typename ConfigType , typename DiagramType >

clanguml::common::generators::mermaid::generator< ConfigType, DiagramType >::generator	(	ConfigType &	config,
		DiagramType &	model
	)

inline

Constructor.

Parameters

config Reference to instance of model Reference to instance of clanguml::model::diagram

Definition at line 66 of file generator.h.

        : clanguml::common::generators::generator<ConfigType, DiagramType>{
              config, model}
    {
    }

◆ ~generator()

template<typename ConfigType , typename DiagramType >

clanguml::common::generators::mermaid::generator< ConfigType, DiagramType >::~generator ( )

overridevirtualdefault

Reimplemented from clanguml::common::generators::generator< ConfigType, DiagramType >.

Member Function Documentation

◆ generate()

template<typename C , typename D >

void clanguml::common::generators::mermaid::generator< C, D >::generate ( std::ostream & ostr ) const

overridevirtual

Generate diagram.

This is the main diagram generation entrypoint. It is responsible for calling other methods in appropriate order to generate the diagram into the output stream. It generates diagram elements, that are common to all types of diagrams in a given generator.

Parameters

ostr	Output stream

Implements clanguml::common::generators::generator< ConfigType, DiagramType >.

Definition at line 176 of file generator.h.

{
    const auto &config = generators::generator<C, D>::config();
    const auto &model = generators::generator<C, D>::model();
 
    if (!config.allow_empty_diagrams() && model.is_empty() &&
        config.mermaid().before.empty() && config.mermaid().after.empty()) {
        throw clanguml::error::empty_diagram_error{
            "Diagram configuration resulted in empty diagram."};
    }
 
    generators::generator<C, D>::update_context();
 
    generate_title(ostr);
 
    generate_diagram_type(ostr);
 
    generate_mermaid_directives(ostr, config.mermaid().before);
 
    generate_diagram(ostr);
 
    generate_mermaid_directives(ostr, config.mermaid().after);
 
    generate_metadata(ostr);
}

◆ generate_diagram()

template<typename ConfigType , typename DiagramType >

virtual void clanguml::common::generators::mermaid::generator< ConfigType, DiagramType >::generate_diagram ( std::ostream & ostr ) const

pure virtual

Generate diagram specific part.

This method must be implemented in subclasses for specific diagram types.

Parameters

ostr	Output stream

Implemented in clanguml::class_diagram::generators::mermaid::generator, clanguml::include_diagram::generators::mermaid::generator, clanguml::package_diagram::generators::mermaid::generator, and clanguml::sequence_diagram::generators::mermaid::generator.

◆ generate_diagram_type()

template<typename ConfigType , typename DiagramType >

virtual void clanguml::common::generators::mermaid::generator< ConfigType, DiagramType >::generate_diagram_type ( std::ostream & ostr ) const

pure virtual

Generate the diagram type.

This method must be overriden for each diagram type (e.g. it renders a single line classDiagram for Mermaid class diagrams.

Parameters

ostr	Output stream

Implemented in clanguml::class_diagram::generators::mermaid::generator, clanguml::include_diagram::generators::mermaid::generator, clanguml::package_diagram::generators::mermaid::generator, and clanguml::sequence_diagram::generators::mermaid::generator.

◆ generate_link()

template<typename C , typename D >

template<typename E >

void clanguml::common::generators::mermaid::generator< C, D >::generate_link	(	std::ostream &	ostr,
		const E &	e
	)		const

Generate hyper link to element.

This method renders links to URL's based on templates provided in the configuration file (e.g. Git browser with specific line and column offset)

Parameters

ostr	Output stream
e	Reference to diagram element

Template Parameters

E	Diagram element type

Definition at line 204 of file generator.h.

{
    if (e.file().empty() && e.file_relative().empty())
        return;
 
    auto maybe_link_pattern = generators::generator<C, D>::get_link_pattern(e);
 
    if (!maybe_link_pattern)
        return;
 
    const auto &[link_prefix, link_pattern] = *maybe_link_pattern;
 
    ostr << indent(1) << "click " << e.alias() << " href \"";
    try {
        auto ec = generators::generator<C, D>::element_context(e);
        common::generators::make_context_source_relative(ec, link_prefix);
        std::string link{};
        if (!link_pattern.empty()) {
            link = generators::generator<C, D>::env().render(
                std::string_view{link_pattern}, ec);
        }
        if (link.empty())
            link = " ";
        ostr << link;
    }
    catch (const inja::json::parse_error &e) {
        LOG_ERROR("Failed to parse Jinja template: {}", link_pattern);
        ostr << " ";
    }
    catch (const inja::json::exception &e) {
        LOG_ERROR("Failed to render comment directive: \n{}\n due to: {}",
            link_pattern, e.what());
        ostr << " ";
    }
    ostr << "\"";
 
    auto maybe_tooltip_pattern =
        generators::generator<C, D>::get_tooltip_pattern(e);
 
    if (maybe_tooltip_pattern) {
        const auto &[tooltip_prefix, tooltip_pattern] = *maybe_tooltip_pattern;
 
        if (!tooltip_pattern.empty()) {
            ostr << " \"";
            try {
                auto ec = generators::generator<C, D>::element_context(e);
                common::generators::make_context_source_relative(
                    ec, tooltip_prefix);
                auto tooltip_text = generators::generator<C, D>::env().render(
                    std::string_view{tooltip_pattern}, ec);
                util::replace_all(tooltip_text, "\"", "&bdquo;");
                ostr << tooltip_text;
            }
            catch (const inja::json::parse_error &e) {
                LOG_ERROR(
                    "Failed to parse Jinja template: {}", tooltip_pattern);
                ostr << " ";
            }
            catch (const inja::json::exception &e) {
                LOG_ERROR(
                    "Failed to render PlantUML directive: \n{}\n due to: {}",
                    tooltip_pattern, e.what());
                ostr << " ";
            }
 
            ostr << "\"";
        }
    }
    ostr << "\n";
}

◆ generate_mermaid_directives()

template<typename C , typename D >

void clanguml::common::generators::mermaid::generator< C, D >::generate_mermaid_directives	(	std::ostream &	ostr,
		const std::vector< std::string > &	directives
	)		const

Generate MermaidJS directives from config file.

This method renders the MermaidJS directives provided in the configuration file, including resolving any element aliases and Jinja templates.

Parameters

ostr	Output stream
directives	List of directives from the configuration file

Definition at line 276 of file generator.h.

{
 
    const auto &config = generators::generator<C, D>::config();
    const auto &model = generators::generator<C, D>::model();
 
    using common::model::namespace_;
 
    for (const auto &d : directives) {
        try {
            // Render the directive with template engine first
            std::string directive{generators::generator<C, D>::env().render(
                std::string_view{d}, generators::generator<C, D>::context())};
 
            // Now search for alias `@A()` directives in the text
            // (this is deprecated)
            std::tuple<std::string, size_t, size_t> alias_match;
            while (util::find_element_alias(directive, alias_match)) {
                const auto full_name =
                    config.using_namespace() | std::get<0>(alias_match);
                auto element_opt = model.get(full_name.to_string());
 
                if (element_opt)
                    directive.replace(std::get<1>(alias_match),
                        std::get<2>(alias_match), element_opt.value().alias());
                else {
                    LOG_ERROR("Cannot find clang-uml alias for element {}",
                        full_name.to_string());
                    directive.replace(std::get<1>(alias_match),
                        std::get<2>(alias_match), "UNKNOWN_ALIAS");
                }
            }
 
            ostr << indent(1) << directive << '\n';
        }
        catch (const clanguml::error::uml_alias_missing &e) {
            LOG_ERROR(
                "Failed to render MermaidJS directive due to unresolvable "
                "alias: {}",
                e.what());
        }
        catch (const inja::json::parse_error &e) {
            LOG_ERROR("Failed to parse Jinja template: {}", d);
        }
        catch (const inja::json::exception &e) {
            LOG_ERROR("Failed to render MermaidJS directive: \n{}\n due to: {}",
                d, e.what());
        }
        catch (const std::regex_error &e) {
            LOG_ERROR("Failed to render MermaidJS directive: \n{}\n due to "
                      "std::regex_error: {}",
                d, e.what());
        }
        catch (const std::exception &e) {
            LOG_ERROR("Failed to render PlantUML directive: \n{}\n due to: {}",
                d, e.what());
        }
    }
}

◆ generate_metadata()

template<typename C , typename D >

void clanguml::common::generators::mermaid::generator< C, D >::generate_metadata ( std::ostream & ostr ) const

Generate comment with diagram metadata.

Parameters

ostr	Output stream

Definition at line 353 of file generator.h.

{
    const auto &config = generators::generator<C, D>::config();
 
    if (config.generate_metadata()) {
        ostr << '\n'
             << "%% Generated with clang-uml, version "
             << clanguml::version::CLANG_UML_VERSION << '\n'
             << "%% LLVM version " << clang::getClangFullVersion() << '\n';
    }
}

◆ generate_notes()

template<typename C , typename D >

void clanguml::common::generators::mermaid::generator< C, D >::generate_notes	(	std::ostream &	ostr,
		const model::diagram_element &	element
	)		const

virtual

Generate diagram notes.

This method adds any notes in the diagram, which were declared in the code using inline directives

Parameters

ostr	Output stream
element	Element to which the note should be attached

Reimplemented in clanguml::package_diagram::generators::mermaid::generator.

Definition at line 338 of file generator.h.

{
    const auto &config = generators::generator<C, D>::config();
 
    for (const auto &decorator : e.decorators()) {
        auto note = std::dynamic_pointer_cast<decorators::note>(decorator);
        if (note && note->applies_to_diagram(config.name)) {
            ostr << indent(1) << "note for " << e.alias() << " \"" << note->text
                 << "\"" << '\n';
        }
    }
}

◆ generate_title()

template<typename C , typename D >

void clanguml::common::generators::mermaid::generator< C, D >::generate_title ( std::ostream & ostr ) const

Generate diagram title.

Generates a MermaidJS diagram title directive if diagram title is provided in the diagram configuration.

Parameters

ostr	Output stream

Definition at line 366 of file generator.h.

{
    const auto &config = generators::generator<C, D>::config();
 
    if (config.title) {
        ostr << "---\n";
        ostr << "title: " << config.title() << '\n';
        ostr << "---\n";
    }
}

◆ print_debug()

template<typename C , typename D >

void clanguml::common::generators::mermaid::generator< C, D >::print_debug	(	const common::model::source_location &	e,
		std::ostream &	ostr
	)		const

Print debug information in diagram comments.

Parameters

m	Diagram element to describe
ostr	Output stream

Definition at line 378 of file generator.h.

{
    const auto &config = generators::generator<C, D>::config();
 
    if (config.debug_mode())
        ostr << "%% " << e.file() << ":" << e.line() << '\n';
}

Member Data Documentation

◆ m_generated_aliases

template<typename ConfigType , typename DiagramType >

std::set<std::string> clanguml::common::generators::mermaid::generator< ConfigType, DiagramType >::m_generated_aliases

mutableprotected

Definition at line 172 of file generator.h.

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

src/common/generators/mermaid/generator.h

Detailed Description

Public Member Functions

Protected Attributes

Constructor & Destructor Documentation

◆ generator()

◆ ~generator()

Member Function Documentation

◆ generate()

◆ generate_diagram()

◆ generate_diagram_type()

◆ generate_link()

◆ generate_mermaid_directives()

◆ generate_metadata()

◆ generate_notes()

◆ generate_title()

◆ print_debug()

Member Data Documentation

◆ m_generated_aliases