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 41 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.

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
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 49 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::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 76 of file generator.h.

76{ return config_; }

◆ context()

template<typename C , typename D >

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

Definition at line 140 of file generator.h.

{
    return m_context;
}

◆ element_context()

template<typename C , typename D >

template<typename E >

inja::json clanguml::common::generators::generator< C, D >::element_context ( const E & e ) const

Definition at line 259 of file generator.h.

{
    const auto &diagram_context = context();
 
    inja::json ctx;
    ctx["element"] = e.context();
#if _MSC_VER
    if (ctx.contains("git")) {
#else
    if (diagram_context.template contains("git")) {
#endif
        ctx["git"] = diagram_context["git"];
    }
 
    if (!e.file().empty()) {
        std::filesystem::path file{e.file()};
        std::string git_relative_path = file.string();
        if (!e.file_relative().empty()) {
#if _MSC_VER
            if (file.is_absolute() && ctx.contains("git")) {
#else
            if (file.is_absolute() &&
                diagram_context.template contains("git")) {
#endif
                git_relative_path = std::filesystem::relative(
                    file, diagram_context["git"]["toplevel"])
                                        .string();
                ctx["element"]["source"]["path"] =
                    util::path_to_url(git_relative_path);
            }
            else {
                ctx["element"]["source"]["path"] = e.file();
            }
        }
        else {
            git_relative_path = "";
            ctx["element"]["source"]["path"] = e.file();
        }
 
        ctx["element"]["source"]["full_path"] = file.string();
        ctx["element"]["source"]["name"] = file.filename().string();
        ctx["element"]["source"]["line"] = e.line();
    }
 
    const auto &maybe_comment = e.comment();
    if (maybe_comment) {
        ctx["element"]["comment"] = maybe_comment.value();
    }
 
    return ctx;
}

◆ env()

template<typename C , typename D >

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

Definition at line 146 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::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 313 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 325 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 122 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;
    }
}

◆ init_env()

template<typename C , typename D >

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

Definition at line 151 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 = element_opt.value().context();
 
        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) {
        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>());
 
        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 83 of file generator.h.

83{ return model_; }

◆ update_context()

template<typename C , typename D >

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

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 134 of file generator.h.

{
    m_context["diagram"] = model().context();
}

Member Data Documentation

◆ config_

template<typename ConfigType , typename DiagramType >

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

private

Definition at line 118 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 114 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 115 of file generator.h.

◆ model_

template<typename ConfigType , typename DiagramType >

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

private

Definition at line 119 of file generator.h.

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

src/common/generators/generator.h

Detailed Description

Public Member Functions

Protected Attributes

Private Attributes

Constructor & Destructor Documentation

◆ generator()

◆ ~generator()

Member Function Documentation

◆ config()

◆ context()

◆ element_context()

◆ env()

◆ generate()

◆ get_link_pattern()

◆ get_tooltip_pattern()

◆ init_context()

◆ init_env()

◆ model()

◆ update_context()

Member Data Documentation

◆ config_

◆ m_context

◆ m_env

◆ model_