clanguml::config::diagram Struct Reference

Common diagram configuration type. More...

Detailed Description

Common diagram configuration type.

This class provides common interface for diagram configuration sections of different diagram types.

Definition at line 636 of file config.h.

#include <config.h>

Public Member Functions
	~diagram () override=default
virtual common::model::diagram_t	type () const =0
std::vector< std::string >	glob_translation_units (const std::vector< std::string > &compilation_database_files) const
	Filter translation units based on glob patterns.
std::filesystem::path	make_path_relative (const std::filesystem::path &p) const
	Make path relative to the relative_to config option.
std::vector< std::string >	make_module_relative (const std::optional< std::string > &maybe_module) const
	Make module path relative to using_module configuration option.
std::filesystem::path	root_directory () const
	Returns absolute path of the relative_to option.
std::optional< std::string >	get_together_group (const std::string &full_name) const
void	initialize_type_aliases ()
	Initialize predefined set of C++ type aliases.
Public Member Functions inherited from clanguml::config::inheritable_diagram_options
virtual	~inheritable_diagram_options ()=default
void	inherit (const inheritable_diagram_options &parent)
std::string	simplify_template_type (std::string full_name) const
bool	generate_fully_qualified_name () const
	Whether the diagram element should be fully qualified in diagram.
option< std::filesystem::path > &	get_relative_to ()
	Get reference to relative_to diagram config option.

Public Attributes
std::string	name
option< std::string >	title {"title"}
Public Attributes inherited from clanguml::config::inheritable_diagram_options
option< std::vector< common::string_or_regex > >	glob {"glob"}
option< common::model::namespace_ >	using_namespace {"using_namespace"}
option< std::string >	using_module {"using_module"}
option< bool >	include_relations_also_as_members
option< filter_mode_t >	filter_mode {"filter_mode", filter_mode_t::basic}
option< bool >	include_system_headers {"include_system_headers", false}
option< filter >	include {"include"}
option< filter >	exclude {"exclude"}
option< plantuml >	puml {"plantuml", option_inherit_mode::kAppend}
option< struct mermaid >	mermaid {"mermaid", option_inherit_mode::kAppend}
option< method_arguments >	generate_method_arguments
option< bool >	generate_concept_requirements
option< bool >	group_methods {"group_methods", true}
option< member_order_t >	member_order
option< bool >	generate_packages {"generate_packages", false}
option< package_type_t >	package_type
option< bool >	generate_template_argument_dependencies
option< bool >	skip_redundant_dependencies
option< generate_links_config >	generate_links {"generate_links"}
option< git_config >	git {"git"}
option< layout_hints >	layout {"layout"}
option< std::filesystem::path >	base_directory {"__parent_path"}
option< bool >	generate_system_headers {"generate_system_headers", false}
option< relationship_hints_t >	relationship_hints {"relationship_hints"}
option< type_aliases_t >	type_aliases
option< comment_parser_t >	comment_parser
option< bool >	combine_free_functions_into_file_participants
option< bool >	inline_lambda_messages {"inline_lambda_messages", false}
option< bool >	generate_return_types {"generate_return_types", false}
option< bool >	generate_condition_statements
option< std::vector< std::string > >	participants_order {"participants_order"}
option< bool >	generate_message_comments {"generate_message_comments", false}
option< unsigned >	message_comment_width
option< bool >	debug_mode {"debug_mode", false}
option< bool >	generate_metadata {"generate_metadata", true}
option< bool >	allow_empty_diagrams {"allow_empty_diagrams", false}

Additional Inherited Members
Protected Attributes inherited from clanguml::config::inheritable_diagram_options
option< std::filesystem::path >	relative_to {"relative_to"}

Constructor & Destructor Documentation

~diagram()

clanguml::config::diagram::~diagram ( )

overridedefault

Member Function Documentation

get_together_group()

std::optional< std::string > clanguml::config::diagram::get_together_group

(

const std::string &

full_name

)

const

Definition at line 393 of file config.cc.

{
    const auto relative_name = using_namespace().relative(full_name);
 
    for (const auto &[hint_target, hints] : layout()) {
        for (const auto &hint : hints) {
            if (hint.hint == hint_t::together) {
                const auto &together_others =
                    std::get<std::vector<std::string>>(hint.entity);
 
                if ((full_name == hint_target) ||
                    util::contains(together_others, full_name))
                    return hint_target;
 
                if ((relative_name == hint_target) ||
                    util::contains(together_others, relative_name))
                    return hint_target;
            }
        }
    }
 
    return std::nullopt;
}

glob_translation_units()

std::vector< std::string > clanguml::config::diagram::glob_translation_units

(

const std::vector< std::string > &

compilation_database_files

)

const

Filter translation units based on glob patterns.

Returns

List of translation unit paths

Definition at line 304 of file config.cc.

{
    // If glob is not defined use all translation units from the
    // compilation database
    if (!glob.has_value) {
        return compilation_database_files;
    }
 
    // Otherwise, get all translation units matching the glob from diagram
    // configuration
    std::vector<std::string> result{};
 
    LOG_DBG("Looking for translation units in {}", root_directory().string());
 
    for (const auto &g : glob()) {
        if (g.is_regex()) {
            LOG_DBG("Searching glob regex {}", g.to_string());
 
            std::regex regex_pattern(
                g.to_string(), std::regex_constants::optimize);
 
            std::copy_if(compilation_database_files.begin(),
                compilation_database_files.end(), std::back_inserter(result),
                [&regex_pattern](const auto &tu) {
                    std::smatch m;
                    return std::regex_search(tu, m, regex_pattern);
                });
        }
        else {
            std::filesystem::path absolute_glob_path{g.to_string()};
 
#ifdef _MSC_VER
            if (!absolute_glob_path.has_root_name())
#else
            if (!absolute_glob_path.is_absolute())
#endif
                absolute_glob_path = root_directory() / absolute_glob_path;
 
            LOG_DBG("Searching glob path {}", absolute_glob_path.string());
 
            auto matches = glob::glob(absolute_glob_path.string(), true, false);
 
            for (const auto &match : matches) {
                const auto path =
                    std::filesystem::canonical(root_directory() / match);
 
                result.emplace_back(path.string());
            }
        }
    }
 
    return result;
}

initialize_type_aliases()

void clanguml::config::diagram::initialize_type_aliases

(

)

Initialize predefined set of C++ type aliases.

This method is responsible for setting up a predefined set of C++ aliases to make the diagrams look nicer, for instance we want to have std::string instead of std::basic_string<char>.

Definition at line 418 of file config.cc.

{
    if (type_aliases().count("std::basic_string<char>") == 0U) {
        type_aliases().insert({"std::basic_string<char>", "std::string"});
    }
    if (type_aliases().count("std::basic_string<char,std::char_traits<"
                             "char>,std::allocator<char>>") == 0U) {
        type_aliases().insert({"std::basic_string<char,std::char_traits<"
                               "char>,std::allocator<char>>",
            "std::string"});
    }
    if (type_aliases().count("std::basic_string<wchar_t>") == 0U) {
        type_aliases().insert({"std::basic_string<wchar_t>", "std::wstring"});
    }
    if (type_aliases().count("std::basic_string<char16_t>") == 0U) {
        type_aliases().insert(
            {"std::basic_string<char16_t>", "std::u16string"});
    }
    if (type_aliases().count("std::basic_string<char32_t>") == 0U) {
        type_aliases().insert(
            {"std::basic_string<char32_t>", "std::u32string"});
    }
    if (type_aliases().count("std::integral_constant<bool,true>") == 0U) {
        type_aliases().insert(
            {"std::integral_constant<bool,true>", "std::true_type"});
    }
    if (type_aliases().count("std::integral_constant<bool,false>") == 0U) {
        type_aliases().insert(
            {"std::integral_constant<bool,false>", "std::false_type"});
    }
#if LLVM_VERSION_MAJOR >= 16
    if (type_aliases().count("std::basic_string") == 0U) {
        type_aliases().insert({"std::basic_string", "std::string"});
    }
#endif
}

make_module_relative()

std::vector< std::string > clanguml::config::diagram::make_module_relative

(

const std::optional< std::string > &

maybe_module

)

const

Make module path relative to using_module configuration option.

Parameters

p	Input path

Returns

Relative path

Definition at line 370 of file config.cc.

{
    if (!maybe_module)
        return {};
 
    auto module_path = common::model::path(
        maybe_module.value(), common::model::path_type::kModule)
                           .tokens();
 
    if (using_module.has_value) {
        auto using_module_path = common::model::path(
            using_module(), common::model::path_type::kModule)
                                     .tokens();
 
        if (util::starts_with(module_path, using_module_path)) {
            util::remove_prefix(module_path, using_module_path);
        }
    }
 
    return module_path;
}

make_path_relative()

std::filesystem::path clanguml::config::diagram::make_path_relative

(

const std::filesystem::path &

p

)

const

Make path relative to the relative_to config option.

Parameters

p	Input path

Returns

Relative path

Definition at line 364 of file config.cc.

{
    return relative(p, root_directory()).lexically_normal().string();
}

root_directory()

std::filesystem::path clanguml::config::diagram::root_directory

(

)

const

Returns absolute path of the relative_to option.

Returns

Absolute path of relative_to

Definition at line 359 of file config.cc.

{
    return weakly_canonical(absolute(base_directory() / relative_to()));
}

type()

virtual common::model::diagram_t clanguml::config::diagram::type ( ) const

pure virtual

Implemented in clanguml::config::class_diagram, clanguml::config::sequence_diagram, clanguml::config::package_diagram, and clanguml::config::include_diagram.

Member Data Documentation

name

std::string clanguml::config::diagram::name

Definition at line 686 of file config.h.

title

option<std::string> clanguml::config::diagram::title {"title"}

Definition at line 688 of file config.h.

---

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

• src/config/config.h
• src/config/config.cc