Base class for diagram generators. More...

Detailed Description

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

Base class for diagram generators.

Template Parameters

ConfigType	Configuration type
DiagramType	Diagram model type

Definition at line 113 of file generator.h.

#include <generator.h>

Public Member Functions
	~generator () override=default

virtual std::vector< std::pair< std::string, property_type > >	graph_property_names () const

virtual std::vector< std::pair< std::string, property_type > >	node_property_names () const

virtual std::vector< std::pair< std::string, property_type > >	edge_property_names () const

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

void	generate_diagram (graphml_node_t &parent) const
	Generate diagram model.

virtual void	generate_top_level_elements (graphml_node_t &parent) const =0
	In a nested diagram, generate the top level elements.

template<typename T >
void	generate_notes (const T &e, graphml_node_t &parent) const
	Generate any notes to be attached to diagram elements.

void	generate_metadata (graphml_t &parent) const
	Generate metadata element with diagram metadata.

virtual void	generate (const model::package &p, graphml_node_t &parent) const
	Generate diagram package.

virtual void	generate_relationships (graphml_node_t &parent) const
	Generate all relationships in the diagram.

virtual void	generate_relationships (const model::diagram_element &c, graphml_node_t &parent) const
	Generate all relationships originating at a diagram element.

template<typename T >
void	generate_link (pugi::xml_node &node, const T &c) const

const property_keymap_t &	graph_properties () const

const property_keymap_t &	node_properties () const

const property_keymap_t &	edge_properties () const

pugi::xml_node	make_node (graphml_node_t &parent, const std::string &id) const

pugi::xml_node	make_graph (graphml_node_t &parent, const std::string &id) const

pugi::xml_node	make_subgraph (graphml_node_t &parent, const std::string &id, const std::string &name="", const std::string &type="") const

void	add_data (pugi::xml_node &node, const std::string &key, const std::string &value, bool cdata=false) const

void	add_cdata (pugi::xml_node &node, const std::string &key, const std::string &value) const

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.

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 Member Functions
void	generate_key (pugi::xml_node &parent, const std::string &attr_name, const std::string &for_value, const std::string &id_value, const std::string &attr_type="string") const

property_keymap_t &	graph_properties ()

property_keymap_t &	node_properties ()

property_keymap_t &	edge_properties ()

Protected Attributes
graphml_node_map_t	graph_ids_ {"g"}

graphml_node_map_t	node_ids_ {"n"}

graphml_node_map_t	edge_ids_ {"e"}

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

inja::Environment	m_env

Private Member Functions
void	generate_keys (graphml_node_t &parent) const

Private Attributes
property_keymap_t	graph_properties_ {"gd"}

property_keymap_t	node_properties_ {"nd"}

property_keymap_t	edge_properties_ {"ed"}

uint64_t	edge_id_ {0}

uint64_t	note_id_ {0}

Constructor & Destructor Documentation

◆ ~generator()

template<typename ConfigType , typename DiagramType >

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

overridevirtualdefault

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

Member Function Documentation

◆ add_cdata()

template<typename C , typename D >

void clanguml::common::generators::graphml::generator< C, D >::add_cdata	(	pugi::xml_node &	node,
		const std::string &	key,
		const std::string &	value
	)		const

Definition at line 544 of file generator.h.

{
    return add_data(node, key_name, value, true);
}

◆ add_data()

template<typename C , typename D >

void clanguml::common::generators::graphml::generator< C, D >::add_data	(	pugi::xml_node &	node,
		const std::string &	key,
		const std::string &	value,
		bool	cdata = `false`
	)		const

Definition at line 520 of file generator.h.

{
    using namespace std::string_literals;
 
    std::optional<std::pair<std::string, property_type>> key_id;
    if (node.name() == "node"s)
        key_id = node_properties().get(key_name);
    else if (node.name() == "graph"s)
        key_id = graph_properties().get(key_name);
    else if (node.name() == "edge"s)
        key_id = edge_properties().get(key_name);
 
    if (key_id.has_value()) {
        auto data = node.append_child("data");
        data.append_attribute("key") = key_id->first;
        if (cdata)
            data.append_child(pugi::node_cdata).set_value(value);
        else
            data.text().set(value);
    }
}

◆ edge_properties() [1/2]

template<typename ConfigType , typename DiagramType >

property_keymap_t & clanguml::common::generators::graphml::generator< ConfigType, DiagramType >::edge_properties ( )

inlineprotected

Definition at line 279 of file generator.h.

279{ return edge_properties_; }

◆ edge_properties() [2/2]

template<typename ConfigType , typename DiagramType >

const property_keymap_t & clanguml::common::generators::graphml::generator< ConfigType, DiagramType >::edge_properties ( ) const

inline

Definition at line 252 of file generator.h.

    {
        return edge_properties_;
    }

◆ edge_property_names()

template<typename ConfigType , typename DiagramType >

virtual std::vector< std::pair< std::string, property_type > > clanguml::common::generators::graphml::generator< ConfigType, DiagramType >::edge_property_names ( ) const

inlinevirtual

Definition at line 145 of file generator.h.

    {
        using namespace std::string_literals;
        return {{"type"s, property_type::kString},
            {"access"s, property_type::kString},
            {"label"s, property_type::kString},
            {"url"s, property_type::kString}};
    }

◆ generate() [1/2]

template<typename ConfigType , typename DiagramType >

virtual void clanguml::common::generators::graphml::generator< ConfigType, DiagramType >::generate	(	const model::package &	p,
		graphml_node_t &	parent
	)		const

inlinevirtual

Generate diagram package.

Parameters

p	Diagram package element
parent	Parent JSON node

Definition at line 218 of file generator.h.

219 {

220 }

◆ generate() [2/2]

template<typename C , typename D >

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

{
    const auto &config = generators::generator<C, D>::config();
 
    graphml_t graph;
 
    auto node_decl = graph.append_child(pugi::node_declaration);
    node_decl.append_attribute("version") = "1.0";
    node_decl.append_attribute("encoding") = "UTF-8";
 
    generate_metadata(graph);
 
    auto graphml = graph.append_child("graphml");
    graphml.append_attribute("xmlns") = "http://graphml.graphdrawing.org/xmlns";
    graphml.append_attribute("xmlns:xsi") =
        "http://www.w3.org/2001/XMLSchema-instance";
    graphml.append_attribute("xsi:schemaLocation") =
        "http://graphml.graphdrawing.org/xmlns "
        "http://graphml.graphdrawing.org/xmlns/1.0/graphml.xsd";
 
    if (config.title) {
        graphml.append_child("desc")
            .append_child(pugi::node_cdata)
            .set_value(config.title());
    }
 
    generate_keys(graphml);
 
    auto graph_node = make_graph(graphml, "G");
 
    if (config.using_namespace) {
        add_data(graph_node, "using_namespace",
            config.using_namespace().to_string());
    }
 
    generate_diagram(graph_node);
 
    graph.save(ostr, "  ");
}

◆ generate_diagram()

template<typename ConfigType , typename DiagramType >

void clanguml::common::generators::graphml::generator< ConfigType, DiagramType >::generate_diagram ( graphml_node_t & parent ) const

inline

Generate diagram model.

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

Parameters

ostr	Output stream

Definition at line 174 of file generator.h.

    {
        generate_top_level_elements(parent);
 
        generate_notes(clanguml::common::generators::generator<ConfigType,
                           DiagramType>::model(),
            parent);
 
        generate_relationships(parent);
    }

◆ generate_key()

template<typename ConfigType , typename DiagramType >

void clanguml::common::generators::graphml::generator< ConfigType, DiagramType >::generate_key	(	pugi::xml_node &	parent,
		const std::string &	attr_name,
		const std::string &	for_value,
		const std::string &	id_value,
		const std::string &	attr_type = `"string"`
	)		const

protected

◆ generate_keys()

template<typename C , typename D >

void clanguml::common::generators::graphml::generator< C, D >::generate_keys ( graphml_node_t & parent ) const

private

Definition at line 579 of file generator.h.

{
    for (const auto &[name, type] : graph_property_names()) {
        const auto [id, t] = graph_properties_.add(name);
        generate_key(parent, name, "graph", id, to_string(type));
    }
 
    for (const auto &[name, type] : node_property_names()) {
        const auto [id, t] = node_properties_.add(name);
        generate_key(parent, name, "node", id, to_string(type));
    }
 
    for (const auto &[name, type] : edge_property_names()) {
        const auto [id, t] = edge_properties_.add(name);
        generate_key(parent, name, "edge", id, to_string(type));
    }
}

◆ generate_link()

template<typename C , typename D >

template<typename T >

void clanguml::common::generators::graphml::generator< C, D >::generate_link	(	pugi::xml_node &	node,
		const T &	c
	)		const

Definition at line 552 of file generator.h.

{
    const auto maybe_link = generator<C, D>::render_link(c);
    const auto maybe_tooltip = generator<C, D>::render_tooltip(c);
 
    if (maybe_link) {
        add_data(node, "url", *maybe_link);
    }
 
    if (maybe_tooltip) {
        add_data(node, "tooltip", *maybe_tooltip);
    }
}

◆ generate_metadata()

template<typename C , typename D >

void clanguml::common::generators::graphml::generator< C, D >::generate_metadata ( graphml_t & parent ) const

Generate metadata element with diagram metadata.

Parameters

parent Root JSON object

Definition at line 467 of file generator.h.

{
    if (generators::generator<C, D>::config().generate_metadata()) {
        auto comment = parent.append_child(pugi::node_comment);
        comment.set_value(fmt::format(
            " Generated with clang-uml {} ", clanguml::version::version()));
 
        comment = parent.append_child(pugi::node_comment);
        comment.set_value(
            fmt::format(" LLVM version {} ", clang::getClangFullVersion()));
    }
}

◆ generate_notes()

template<typename C , typename D >

template<typename T >

void clanguml::common::generators::graphml::generator< C, D >::generate_notes	(	const T &	e,
		graphml_node_t &	parent
	)		const

Generate any notes to be attached to diagram elements.

Parameters

e	Diagram element
parent	Parent GraphML package node to attach the note to

Definition at line 401 of file generator.h.

{
    const auto &config = generators::generator<C, D>::config();
 
    std::vector<std::pair</* element node id */ std::string,
        /* note node id */ std::string>>
        note_id_map;
 
    // First generate the note XML nodes
    auto note_index{0U};
    for (const auto &e : p) {
        // First try to extract notes from comment decorators (i.e. \uml
        // directives in code comments)
        for (const auto &decorator : e->decorators()) {
            auto note = std::dynamic_pointer_cast<decorators::note>(decorator);
            if (note && note->applies_to_diagram(config.name)) {
                auto note_id = node_ids_.add(
                    fmt::format("{}-N_{}", e->alias(), note_index));
                auto maybe_element_node_id = node_ids_.get(e->alias());
                if (maybe_element_node_id) {
                    auto note_node = make_node(parent, note_id);
                    add_data(note_node, "type", "note");
                    add_data(note_node, "name", note->text, true);
                    note_id_map.emplace_back(*maybe_element_node_id, note_id);
                    note_index++;
                }
            }
        }
 
        // Now try to extract notes from `graphml` configuration file section
        if (config.graphml &&
            config.graphml().notes.count(e->full_name(false))) {
            for (const auto &note :
                config.graphml().notes.at(e->full_name(false))) {
                auto note_id = node_ids_.add(
                    fmt::format("{}-N_{}", e->alias(), note_index));
                auto maybe_element_node_id = node_ids_.get(e->alias());
                if (maybe_element_node_id) {
                    auto rendered_note = common::jinja::render_template(
                        generator<C, D>::env(), note);
                    if (rendered_note) {
                        auto note_node = make_node(parent, note_id);
                        add_data(note_node, "type", "note");
                        add_data(note_node, "name", *rendered_note, true);
                        note_id_map.emplace_back(
                            *maybe_element_node_id, note_id);
                        note_index++;
                    }
                }
            }
        }
    }
 
    // Now generate the edges connecting note nodes to element notes
    for (const auto &[element_node_id, note_node_id] : note_id_map) {
        auto edge_node = parent.append_child("edge");
 
        edge_node.append_attribute("id") = fmt::format("e{}", edge_id_++);
        edge_node.append_attribute("source") = note_node_id;
        edge_node.append_attribute("target") = element_node_id;
 
        add_data(edge_node, "type", "none");
    }
}

◆ generate_relationships() [1/2]

template<typename C , typename D >

void clanguml::common::generators::graphml::generator< C, D >::generate_relationships	(	const model::diagram_element &	c,
		graphml_node_t &	parent
	)		const

virtual

Generate all relationships originating at a diagram element.

Template Parameters

T	Type of diagram element

Parameters

c	Diagram diagram element
parent	JSON node

Definition at line 356 of file generator.h.

{
    const auto &model = generator<C, D>::model();
 
    for (const auto &r : c.relationships()) {
        auto target_element = model.get(r.destination());
        if (!target_element.has_value()) {
            LOG_DBG("Skipping {} relation from '{}' to '{}' due "
                    "to unresolved destination id",
                to_string(r.type()), c.full_name(true),
                r.destination().value());
            continue;
        }
 
        const auto maybe_target_id =
            node_ids_.get(target_element.value().alias());
        const auto maybe_src_id = node_ids_.get(c.alias());
 
        if (!maybe_src_id || !maybe_target_id)
            continue;
 
        auto edge_node = parent.append_child("edge");
 
        edge_node.append_attribute("id") = fmt::format("e{}", edge_id_++);
        edge_node.append_attribute("source") = *maybe_src_id;
        edge_node.append_attribute("target") = *maybe_target_id;
 
        const auto maybe_link = generator<C, D>::render_link(r);
 
        if (maybe_link) {
            add_data(edge_node, "url", *maybe_link);
        }
 
        add_data(edge_node, "type", to_string(r.type()));
        if (!r.label().empty())
            add_data(edge_node, "label", r.label());
 
        if (r.access() != access_t::kNone)
            add_data(edge_node, "access", to_string(r.access()));
    }
}

◆ generate_relationships() [2/2]

template<typename ConfigType , typename DiagramType >

virtual void clanguml::common::generators::graphml::generator< ConfigType, DiagramType >::generate_relationships ( graphml_node_t & parent ) const

virtual

Generate all relationships in the diagram.

Parameters

parent GraphML node

◆ generate_top_level_elements()

template<typename ConfigType , typename DiagramType >

virtual void clanguml::common::generators::graphml::generator< ConfigType, DiagramType >::generate_top_level_elements ( graphml_node_t & parent ) const

pure virtual

In a nested diagram, generate the top level elements.

This method iterates over the top level elements. In case the diagram is nested (i.e. includes packages), for each package it recursively call generation of elements contained in each package.

Parameters

parent GraphML node

◆ graph_properties() [1/2]

template<typename ConfigType , typename DiagramType >

property_keymap_t & clanguml::common::generators::graphml::generator< ConfigType, DiagramType >::graph_properties ( )

inlineprotected

Definition at line 277 of file generator.h.

277{ return graph_properties_; }

◆ graph_properties() [2/2]

template<typename ConfigType , typename DiagramType >

const property_keymap_t & clanguml::common::generators::graphml::generator< ConfigType, DiagramType >::graph_properties ( ) const

inline

Definition at line 242 of file generator.h.

    {
        return graph_properties_;
    }

◆ graph_property_names()

template<typename ConfigType , typename DiagramType >

virtual std::vector< std::pair< std::string, property_type > > clanguml::common::generators::graphml::generator< ConfigType, DiagramType >::graph_property_names ( ) const

inlinevirtual

Definition at line 121 of file generator.h.

    {
        using namespace std::string_literals;
        return {
            {"id"s, property_type::kString},
            {"diagram_type"s, property_type::kString},
            {"name"s, property_type::kString},
            {"using_namespace"s, property_type::kString},
        };
    }

◆ make_graph()

template<typename C , typename D >

pugi::xml_node clanguml::common::generators::graphml::generator< C, D >::make_graph	(	graphml_node_t &	parent,
		const std::string &	id
	)		const

Definition at line 490 of file generator.h.

{
    auto result = parent.append_child("graph");
    result.append_attribute("id") = graph_ids_.add(id);
    result.append_attribute("edgedefault").set_value("directed");
    result.append_attribute("parse.nodeids").set_value("canonical");
    result.append_attribute("parse.edgeids").set_value("canonical");
    result.append_attribute("parse.order").set_value("nodesfirst");
    return result;
}

◆ make_node()

template<typename C , typename D >

pugi::xml_node clanguml::common::generators::graphml::generator< C, D >::make_node	(	graphml_node_t &	parent,
		const std::string &	id
	)		const

Definition at line 481 of file generator.h.

{
    auto result = parent.append_child("node");
    result.append_attribute("id") = id;
    return result;
}

◆ make_subgraph()

template<typename C , typename D >

pugi::xml_node clanguml::common::generators::graphml::generator< C, D >::make_subgraph	(	graphml_node_t &	parent,
		const std::string &	id,
		const std::string &	name = `""`,
		const std::string &	type = `""`
	)		const

Definition at line 503 of file generator.h.

{
    auto graph_node = parent.append_child("node");
    graph_node.append_attribute("id") = node_ids_.add(id);
 
    if (!name.empty())
        add_data(graph_node, "name", name);
 
    if (!type.empty())
        add_data(graph_node, "type", type);
 
    return graph_node;
}

◆ node_properties() [1/2]

template<typename ConfigType , typename DiagramType >

property_keymap_t & clanguml::common::generators::graphml::generator< ConfigType, DiagramType >::node_properties ( )

inlineprotected

Definition at line 278 of file generator.h.

278{ return node_properties_; }

◆ node_properties() [2/2]

template<typename ConfigType , typename DiagramType >

const property_keymap_t & clanguml::common::generators::graphml::generator< ConfigType, DiagramType >::node_properties ( ) const

inline

Definition at line 247 of file generator.h.

    {
        return node_properties_;
    }

◆ node_property_names()

template<typename ConfigType , typename DiagramType >

virtual std::vector< std::pair< std::string, property_type > > clanguml::common::generators::graphml::generator< ConfigType, DiagramType >::node_property_names ( ) const

inlinevirtual

Reimplemented in clanguml::class_diagram::generators::graphml::generator, and clanguml::include_diagram::generators::graphml::generator.

Definition at line 133 of file generator.h.

    {
        using namespace std::string_literals;
        return {{"id"s, property_type::kString},
            {"type"s, property_type::kString},
            {"name"s, property_type::kString},
            {"stereotype"s, property_type::kString},
            {"url"s, property_type::kString},
            {"tooltip"s, property_type::kString}};
    }

Member Data Documentation

◆ edge_id_

template<typename ConfigType , typename DiagramType >

uint64_t clanguml::common::generators::graphml::generator< ConfigType, DiagramType >::edge_id_ {0}

mutableprivate

Definition at line 292 of file generator.h.

◆ edge_ids_

template<typename ConfigType , typename DiagramType >

graphml_node_map_t clanguml::common::generators::graphml::generator< ConfigType, DiagramType >::edge_ids_ {"e"}

mutableprotected

Definition at line 283 of file generator.h.

◆ edge_properties_

template<typename ConfigType , typename DiagramType >

property_keymap_t clanguml::common::generators::graphml::generator< ConfigType, DiagramType >::edge_properties_ {"ed"}

mutableprivate

Definition at line 290 of file generator.h.

◆ graph_ids_

template<typename ConfigType , typename DiagramType >

graphml_node_map_t clanguml::common::generators::graphml::generator< ConfigType, DiagramType >::graph_ids_ {"g"}

mutableprotected

Definition at line 281 of file generator.h.

◆ graph_properties_

template<typename ConfigType , typename DiagramType >

property_keymap_t clanguml::common::generators::graphml::generator< ConfigType, DiagramType >::graph_properties_ {"gd"}

mutableprivate

Definition at line 288 of file generator.h.

◆ node_ids_

template<typename ConfigType , typename DiagramType >

graphml_node_map_t clanguml::common::generators::graphml::generator< ConfigType, DiagramType >::node_ids_ {"n"}

mutableprotected

Definition at line 282 of file generator.h.

◆ node_properties_

template<typename ConfigType , typename DiagramType >

property_keymap_t clanguml::common::generators::graphml::generator< ConfigType, DiagramType >::node_properties_ {"nd"}

mutableprivate

Definition at line 289 of file generator.h.

◆ note_id_

template<typename ConfigType , typename DiagramType >

uint64_t clanguml::common::generators::graphml::generator< ConfigType, DiagramType >::note_id_ {0}

mutableprivate

Definition at line 293 of file generator.h.

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

src/common/generators/graphml/generator.h

Detailed Description

Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Constructor & Destructor Documentation

◆ ~generator()

Member Function Documentation

◆ add_cdata()

◆ add_data()

◆ edge_properties() [1/2]

◆ edge_properties() [2/2]

◆ edge_property_names()

◆ generate() [1/2]

◆ generate() [2/2]

◆ generate_diagram()

◆ generate_key()

◆ generate_keys()

◆ generate_link()

◆ generate_metadata()

◆ generate_notes()

◆ generate_relationships() [1/2]

◆ generate_relationships() [2/2]

◆ generate_top_level_elements()

◆ graph_properties() [1/2]

◆ graph_properties() [2/2]

◆ graph_property_names()

◆ make_graph()

◆ make_node()

◆ make_subgraph()

◆ node_properties() [1/2]

◆ node_properties() [2/2]

◆ node_property_names()

Member Data Documentation

◆ edge_id_

◆ edge_ids_

◆ edge_properties_

◆ graph_ids_

◆ graph_properties_

◆ node_ids_

◆ node_properties_

◆ note_id_