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 714 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, bool is_fixed=false) 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::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.
std::filesystem::path	root_directory () const
	Returns absolute path of the relative_to option.
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< glob_t >	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< struct graphml >	graphml {"graphml", option_inherit_mode::kAppend}
option< method_arguments >	generate_method_arguments
option< bool >	generate_method_argument_names
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_return_values {"generate_return_values", 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< bool >	fold_repeated_activities {"fold_repeated_activities", false}
option< unsigned >	message_comment_width
option< unsigned >	message_name_width
option< bool >	debug_mode {"debug_mode", false}
option< bool >	generate_metadata {"generate_metadata", true}
option< bool >	allow_empty_diagrams {"allow_empty_diagrams", false}
option< inja::json >	user_data {"user_data", {}, option_inherit_mode::kAppend}

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 524 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,
		bool	is_fixed = false
	)		const

Filter translation units based on glob patterns.

Returns

List of translation unit paths

Definition at line 360 of file config.cc.

{
    // Make sure that the paths are in preferred format for a given platform
    // before intersecting the matches with compliation database
    std::vector<std::string> compilation_database_paths;
    compilation_database_paths.reserve(compilation_database_files.size());
    for (const auto &cdf : compilation_database_files) {
        std::filesystem::path p{cdf};
        p.make_preferred();
        compilation_database_paths.emplace_back(p.string());
    }
 
    // If glob is not defined use all translation units from the
    // compilation database
    if (!glob.has_value || (glob().include.empty() && glob().exclude.empty())) {
        return compilation_database_paths;
    }
 
    // Create also a canonical database paths set
    std::vector<std::string> canonical_compilation_database_paths;
    canonical_compilation_database_paths.reserve(
        compilation_database_paths.size());
    for (const auto &cdp : compilation_database_paths) {
        auto canonical_p = weakly_canonical(std::filesystem::path{cdp});
        canonical_compilation_database_paths.emplace_back(canonical_p.string());
    }
 
    // Otherwise, get all translation units matching the glob from diagram
    // configuration
    std::vector<std::string> glob_matches{};
 
    LOG_DBG("Looking for translation units in {}", root_directory().string());
 
    for (const auto &g : glob().include) {
        if (g.is_regex()) {
            LOG_DBG("Matching inclusive glob regex {}", g.to_string());
 
            std::regex regex_pattern(
                g.to_string(), std::regex_constants::optimize);
 
            std::copy_if(compilation_database_paths.begin(),
                compilation_database_paths.end(),
                std::back_inserter(glob_matches),
                [&regex_pattern](const auto &tu) {
                    std::smatch m;
 
                    return exists(std::filesystem::path{tu}) &&
                        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);
 
                glob_matches.emplace_back(path.string());
            }
        }
    }
 
    if (glob().include.empty())
        glob_matches = compilation_database_paths;
 
    for (const auto &g : glob().exclude) {
        if (g.is_regex()) {
            LOG_DBG("Matching exclusive glob regex {}", g.to_string());
 
            std::regex regex_pattern(
                g.to_string(), std::regex_constants::optimize);
 
            for (const auto &cdf : compilation_database_paths) {
                std::smatch m;
                if (std::regex_search(cdf, m, regex_pattern)) {
                    glob_matches.erase(
                        remove(begin(glob_matches), end(glob_matches), cdf),
                        glob_matches.end());
                }
            }
        }
        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 exclusive 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);
 
                glob_matches.erase(remove(begin(glob_matches),
                                       end(glob_matches), path.string()),
                    glob_matches.end());
            }
        }
    }
 
    // Calculate intersection between glob matches and compilation database
    std::vector<std::string> result;
    for (const auto &gm : glob_matches) {
        std::filesystem::path gm_path{gm};
        gm_path.make_preferred();
        if (is_fixed || util::contains(compilation_database_paths, gm_path) ||
            util::contains(canonical_compilation_database_paths, gm_path) ||
            util::contains(compilation_database_files, gm)) {
            result.emplace_back(gm_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 549 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 501 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 495 of file config.cc.

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

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 758 of file config.h.

title

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

Definition at line 760 of file config.h.

---

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

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