Common diagram generator interface. More...

Detailed Description

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

Common diagram generator interface.

This class defines common interface for all diagram generators.

Definition at line 44 of file generator.h.

#include <generator.h>

Public Member Functions
	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.

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

std::optional< std::string >	render_link (const common::model::diagram_element &e) const

std::optional< std::string >	render_link (const common::model::relationship &e) const

std::optional< std::string >	render_tooltip (const common::model::diagram_element &e) const

std::optional< std::string >	render_tooltip (const common::model::relationship &e) 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
inja::json	m_context

inja::Environment	m_env

Private Attributes
ConfigType &	config_

DiagramType &	model_

Constructor & Destructor Documentation

◆ generator()

template<typename ConfigType , typename DiagramType >

clanguml::common::generators::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 52 of file generator.h.

        : config_{config}
        , model_{model}
    {
        init_context();
        init_env();
    }

◆ ~generator()

template<typename ConfigType , typename DiagramType >

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

virtualdefault

Reimplemented in clanguml::common::generators::graphml::generator< ConfigType, DiagramType >, clanguml::common::generators::json::generator< ConfigType, DiagramType >, clanguml::common::generators::mermaid::generator< ConfigType, DiagramType >, and clanguml::common::generators::plantuml::generator< ConfigType, DiagramType >.

Member Function Documentation

◆ config()

template<typename ConfigType , typename DiagramType >

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

inline

Get reference to diagram config.

Returns: Diagram config

Definition at line 79 of file generator.h.

79{ return config_; }

◆ context()

template<typename C , typename D >

const inja::json & clanguml::common::generators::generator< C, D >::context

Definition at line 152 of file generator.h.

{
    return m_context;
}

◆ env()

template<typename C , typename D >

inja::Environment & clanguml::common::generators::generator< C, D >::env

Definition at line 158 of file generator.h.

{
    return m_env;
}

◆ generate()

template<typename ConfigType , typename DiagramType >

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

pure virtual

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

Implemented in clanguml::common::generators::graphml::generator< ConfigType, DiagramType >, clanguml::common::generators::json::generator< ConfigType, DiagramType >, clanguml::common::generators::mermaid::generator< ConfigType, DiagramType >, and clanguml::common::generators::plantuml::generator< ConfigType, DiagramType >.

◆ get_link_pattern()

template<typename C , typename D >

std::optional< std::pair< std::string, std::string > > clanguml::common::generators::generator< C, D >::get_link_pattern ( const common::model::source_location & sl ) const

Definition at line 274 of file generator.h.

{
    if (sl.file_relative().empty()) {
        return config().generate_links().get_link_pattern(sl.file());
    }
 
    return config().generate_links().get_link_pattern(sl.file_relative());
}

◆ get_tooltip_pattern()

template<typename C , typename D >

std::optional< std::pair< std::string, std::string > > clanguml::common::generators::generator< C, D >::get_tooltip_pattern ( const common::model::source_location & sl ) const

Definition at line 286 of file generator.h.

{
    if (sl.file_relative().empty()) {
        return config().generate_links().get_tooltip_pattern(sl.file());
    }
 
    return config().generate_links().get_tooltip_pattern(sl.file_relative());
}

◆ init_context()

template<typename C , typename D >

void clanguml::common::generators::generator< C, D >::init_context

Initialize diagram Jinja context.

Definition at line 135 of file generator.h.

{
    const auto &config = generators::generator<C, D>::config();
 
    if (config.git) {
        m_context["git"]["branch"] = config.git().branch;
        m_context["git"]["revision"] = config.git().revision;
        m_context["git"]["commit"] = config.git().commit;
        m_context["git"]["toplevel"] = config.git().toplevel;
    }
 
    if (config.user_data) {
        m_context["user_data"] = config.user_data();
    }
}

◆ init_env()

template<typename C , typename D >

void clanguml::common::generators::generator< C, D >::init_env

Definition at line 163 of file generator.h.

{
    const auto &model = generators::generator<C, D>::model();
    const auto &config = generators::generator<C, D>::config();
 
    //
    // Add basic string functions to inja environment
    //
 
    // Check if string is empty
    m_env.add_callback("empty", 1, [](inja::Arguments &args) {
        return args.at(0)->get<std::string>().empty();
    });
 
    // Remove spaces from the left of a string
    m_env.add_callback("ltrim", 1, [](inja::Arguments &args) {
        return util::ltrim(args.at(0)->get<std::string>());
    });
 
    // Remove trailing spaces from a string
    m_env.add_callback("rtrim", 1, [](inja::Arguments &args) {
        return util::rtrim(args.at(0)->get<std::string>());
    });
 
    // Remove spaces before and after a string
    m_env.add_callback("trim", 1, [](inja::Arguments &args) {
        return util::trim(args.at(0)->get<std::string>());
    });
 
    // Make a string shorted with a limit to
    m_env.add_callback("abbrv", 2, [](inja::Arguments &args) {
        return util::abbreviate(
            args.at(0)->get<std::string>(), args.at(1)->get<unsigned>());
    });
 
    m_env.add_callback("replace", 3, [](inja::Arguments &args) {
        std::string result = args[0]->get<std::string>();
        std::regex pattern(args[1]->get<std::string>());
        return std::regex_replace(result, pattern, args[2]->get<std::string>());
    });
 
    m_env.add_callback("split", 2, [](inja::Arguments &args) {
        return util::split(
            args[0]->get<std::string>(), args[1]->get<std::string>());
    });
 
    //
    // Add PlantUML specific functions
    //
 
    // Return the entire element JSON context based on element name
    // e.g.:
    //   {{ element("clanguml::t00050::A").comment }}
    //
    m_env.add_callback("element", 1, [&model, &config](inja::Arguments &args) {
        inja::json res{};
        auto element_opt = model.get_with_namespace(
            args[0]->get<std::string>(), config.using_namespace());
 
        if (element_opt.has_value()) {
            res = common::jinja::diagram_context<model::element>{
                dynamic_cast<const model::element &>(element_opt.value())};
        }
 
        return res;
    });
 
    // Convert C++ entity to PlantUML alias, e.g.
    //   "note left of {{ alias("A") }}: This is a note"
    // Shortcut to:
    //   {{ element("A").alias }}
    //
    m_env.add_callback("alias", 1, [&model, &config](inja::Arguments &args) {
        const auto &element_name = args[0]->get<std::string>();
        auto element_opt =
            model.get_with_namespace(element_name, config.using_namespace());
 
        if (!element_opt.has_value())
            throw clanguml::error::uml_alias_missing(
                args[0]->get<std::string>());
 
        return element_opt.value().alias();
    });
 
    // Get elements' comment:
    //   "note left of {{ alias("A") }}: {{ comment("A") }}"
    // Shortcut to:
    //   {{ element("A").comment }}
    //
    m_env.add_callback("comment", 1, [&model, &config](inja::Arguments &args) {
        inja::json res{};
        auto element_opt = model.get_with_namespace(
            args[0]->get<std::string>(), config.using_namespace());
 
        if (!element_opt.has_value())
            throw clanguml::error::uml_alias_missing(
                args[0]->get<std::string>());
 
        auto comment = element_opt.value().comment();
 
        if (comment.has_value()) {
            assert(comment.value().is_object());
            res = comment.value();
        }
 
        return res;
    });
}

◆ model()

template<typename ConfigType , typename DiagramType >

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

inline

Get reference to diagram model.

Returns: Diagram model

Definition at line 86 of file generator.h.

86{ return model_; }

◆ render_link() [1/2]

template<typename C , typename D >

std::optional< std::string > clanguml::common::generators::generator< C, D >::render_link ( const common::model::diagram_element & e ) const

Definition at line 297 of file generator.h.

{
    using common::generators::make_context_source_relative;
    using common::jinja::render_template;
 
    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;
 
    inja::json ec = jinja::element_context<common::model::diagram_element>(
        e, generators::generator<C, D>::context());
 
    make_context_source_relative(ec, link_prefix);
 
    return render_template(
        generators::generator<C, D>::env(), ec, link_pattern);
}

◆ render_link() [2/2]

template<typename C , typename D >

std::optional< std::string > clanguml::common::generators::generator< C, D >::render_link ( const common::model::relationship & e ) const

Definition at line 323 of file generator.h.

{
    using common::generators::make_context_source_relative;
    using common::jinja::render_template;
 
    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;
 
    inja::json ec = jinja::element_context<common::model::relationship>(
        e, generators::generator<C, D>::context());
 
    make_context_source_relative(ec, link_prefix);
 
    return render_template(
        generators::generator<C, D>::env(), ec, link_pattern);
}

◆ render_tooltip() [1/2]

template<typename C , typename D >

std::optional< std::string > clanguml::common::generators::generator< C, D >::render_tooltip ( const common::model::diagram_element & e ) const

Definition at line 349 of file generator.h.

{
    using common::generators::make_context_source_relative;
    using common::jinja::render_template;
 
    if (e.file().empty() && e.file_relative().empty())
        return {};
 
    auto maybe_tooltip_pattern =
        generators::generator<C, D>::get_tooltip_pattern(e);
 
    if (!maybe_tooltip_pattern)
        return {};
 
    const auto &[tooltip_prefix, tooltip_pattern] = *maybe_tooltip_pattern;
 
    inja::json ec = jinja::element_context<common::model::diagram_element>(
        e, generators::generator<C, D>::context());
 
    make_context_source_relative(ec, tooltip_prefix);
 
    return render_template(
        generators::generator<C, D>::env(), ec, tooltip_pattern);
}

◆ render_tooltip() [2/2]

template<typename C , typename D >

std::optional< std::string > clanguml::common::generators::generator< C, D >::render_tooltip ( const common::model::relationship & e ) const

Definition at line 376 of file generator.h.

{
    using common::generators::make_context_source_relative;
    using common::jinja::render_template;
 
    if (e.file().empty() && e.file_relative().empty())
        return {};
 
    auto maybe_tooltip_pattern =
        generators::generator<C, D>::get_tooltip_pattern(e);
 
    if (!maybe_tooltip_pattern)
        return {};
 
    const auto &[tooltip_prefix, tooltip_pattern] = *maybe_tooltip_pattern;
 
    inja::json ec = jinja::element_context<common::model::relationship>(
        e, generators::generator<C, D>::context());
 
    make_context_source_relative(ec, tooltip_prefix);
 
    return render_template(
        generators::generator<C, D>::env(), ec, tooltip_pattern);
}

◆ update_context()

template<typename C , typename D >

template void clanguml::common::generators::generator< ConfigType, DiagramType >::update_context ( ) const

Update diagram Jinja context.

This method updates the diagram context with models properties which can be used to render Jinja templates in the diagram (e.g. in notes or links)

Definition at line 10 of file generator.cc.

{
    m_context["diagram"] = common::jinja::diagram_context<D>(model());
}

Member Data Documentation

◆ config_

template<typename ConfigType , typename DiagramType >

ConfigType& clanguml::common::generators::generator< ConfigType, DiagramType >::config_

private

Definition at line 131 of file generator.h.

◆ m_context

template<typename ConfigType , typename DiagramType >

inja::json clanguml::common::generators::generator< ConfigType, DiagramType >::m_context

mutableprotected

Definition at line 127 of file generator.h.

◆ m_env

template<typename ConfigType , typename DiagramType >

inja::Environment clanguml::common::generators::generator< ConfigType, DiagramType >::m_env

mutableprotected

Definition at line 128 of file generator.h.

◆ model_

template<typename ConfigType , typename DiagramType >

DiagramType& clanguml::common::generators::generator< ConfigType, DiagramType >::model_

private

Definition at line 132 of file generator.h.

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

src/common/generators/generator.h
src/common/generators/generator.cc

Detailed Description

Public Member Functions

Protected Attributes

Private Attributes

Constructor & Destructor Documentation

◆ generator()

◆ ~generator()

Member Function Documentation

◆ config()

◆ context()

◆ env()

◆ generate()

◆ get_link_pattern()

◆ get_tooltip_pattern()

◆ init_context()

◆ init_env()

◆ model()

◆ render_link() [1/2]

◆ render_link() [2/2]

◆ render_tooltip() [1/2]

◆ render_tooltip() [2/2]

◆ update_context()

Member Data Documentation

◆ config_

◆ m_context

◆ m_env

◆ model_