Detailed Description

src/common/model/diagram_element.h

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

This namespace provides common interfaces for diagram model, including various diagram elements and diagram filters.

Namespaces
namespace	detail

namespace	tvl

Classes
struct	access_filter

class	advanced_diagram_filter_initializer

struct	allof_filter

struct	anyof_filter

class	basic_diagram_filter_initializer

struct	callee_filter

struct	class_member_filter

struct	class_method_filter

struct	context

struct	context_filter

class	decorated_element
	Base class for decorated diagram elements. More...

class	diagram
	Base class for all diagram models. More...

class	diagram_element
	Base class for standalone diagram elements. More...

class	diagram_filter
	Composite of all diagrams filters. More...

class	diagram_filter_factory

class	diagram_filter_initializer

struct	edge_traversal_filter
	Common template for filters involving traversing relationship graph. More...

class	element
	Base class for any element qualified by namespace. More...

struct	element_filter

struct	element_type_filter

class	element_view

struct	element_views

class	filter_visitor
	Base class for any diagram filter. More...

struct	fs_path_sep

struct	full_name_tag_t

struct	method_type_filter

struct	module_access_filter

struct	modules_filter

struct	name_and_ns_tag

struct	namespace_filter

class	nested_trait
	Base class for elements nested in the diagram. More...

struct	ns_path_separator

class	package
	Diagram element representing namespace or directory package. More...

struct	parents_filter

class	path
	Diagram path. More...

struct	paths_filter

class	relationship
	Class representing any relationship other than inheritance. More...

struct	relationship_filter

class	source_file
	Diagram element representing some file or directory. More...

class	source_location
	Base class of all diagram elements that have source location. More...

class	stylable_element
	Diagram elements to which style can be applied. More...

struct	subclass_filter

class	template_element
	Base class for any element qualified by namespace. More...

class	template_parameter
	Represents template parameter, template arguments or concept constraints. More...

class	template_trait
	Common interface for template diagram elements. More...

Typedefs
using	comment_t = inja::json

using	specializations_filter_t = edge_traversal_filter< class_diagram::model::diagram, class_diagram::model::class_, common::string_or_regex >

using	class_dependants_filter_t = edge_traversal_filter< class_diagram::model::diagram, class_diagram::model::class_, common::string_or_regex >

using	class_dependencies_filter_t = edge_traversal_filter< class_diagram::model::diagram, class_diagram::model::class_, common::string_or_regex >

using	package_dependants_filter_t = edge_traversal_filter< package_diagram::model::diagram, common::model::package, common::string_or_regex >

using	package_dependencies_filter_t = edge_traversal_filter< package_diagram::model::diagram, common::model::package, common::string_or_regex >

using	source_file_dependency_filter_t = edge_traversal_filter< include_diagram::model::diagram, common::model::source_file, std::string, common::model::source_file >

using	namespace_ = path

using	filesystem_path = common::model::path

Enumerations
enum class	diagram_t { kClass , kSequence , kPackage , kInclude }

enum class	module_access_t { kPublic , kPrivate }

enum class	access_t { kPublic , kProtected , kPrivate , kNone }

enum class	relationship_t { kNone , kExtension , kComposition , kAggregation , kContainment , kOwnership , kAssociation , kInstantiation , kFriendship , kAlias , kDependency , kConstraint }

enum class	message_t { kCall , kReturn , kIf , kElse , kElseIf , kIfEnd , kWhile , kWhileEnd , kDo , kDoEnd , kFor , kForEnd , kTry , kCatch , kTryEnd , kSwitch , kCase , kSwitchEnd , kConditional , kConditionalElse , kConditionalEnd , kNone }
	Types of sequence diagram activity elements. More...

enum class	message_scope_t { kNormal , kCondition }
	The scope of the call expression represented in the sequence diagram. More...

enum class	filter_t { kInclusive , kExclusive }

enum class	path_type { kNamespace , kFilesystem , kModule }
	Type of diagram path. More...

enum class	source_file_t { kDirectory , kHeader , kImplementation }

enum class	template_parameter_kind_t { template_type , template_template_type , non_type_template , argument , concept_constraint , empty }

enum class	rpqualifier { kLValueReference , kRValueReference , kPointer , kNone }

Functions
template<>
bool	check_diagram_type< clanguml::class_diagram::model::diagram > (diagram_t t)

template<>
bool	check_diagram_type< clanguml::class_diagram::model::diagram > (diagram_t t)

void	to_json (nlohmann::json &j, const source_location &sl)

void	to_json (nlohmann::json &j, const element &c)

void	to_json (nlohmann::json &j, const template_parameter &c)

void	to_json (nlohmann::json &j, const relationship &c)

void	to_json (json &j, const source_location &sl)

void	to_json (json &j, const element &c)

void	to_json (json &j, const template_parameter &c)

void	to_json (json &j, const relationship &c)

template<typename T >
bool	needs_root_prefix (const T &e)

template<typename DiagramT >
bool	check_diagram_type (diagram_t t)

bool	operator== (const diagram_element &l, const diagram_element &r)

std::ostream &	operator<< (std::ostream &out, const diagram_element &rhs)

bool	operator== (const element &l, const element &r)

std::ostream &	operator<< (std::ostream &out, const element &rhs)

std::string	to_string (relationship_t r)

std::string	to_string (access_t a)

std::string	to_string (module_access_t a)

std::string	to_string (message_t r)

std::string	to_string (const diagram_t t)

std::string	to_string (const message_scope_t t)

diagram_t	from_string (const std::string &s)

template<>
bool	diagram_filter::should_include< std::string > (const std::string &name) const

template<typename Collection >
void	apply_filter (Collection &col, const diagram_filter &filter)

template<typename T >
void	apply_filter (std::vector< std::reference_wrapper< T > > &col, const diagram_filter &filter)

template<>
bool	diagram_filter::should_include< std::string > (const std::string &name) const

std::string	to_string (const path_type pt)

bool	operator== (const relationship &l, const relationship &r)

std::string	to_string (source_file_t sf)

std::string	to_string (template_parameter_kind_t k)

int	calculate_template_params_specialization_match (const std::vector< template_parameter > &specialization, const std::vector< template_parameter > &base_template)
	Calculate the match between 2 template parameter lists.

YAML::Emitter &	operator<< (YAML::Emitter &out, const namespace_ &n)

YAML::Emitter &	operator<< (YAML::Emitter &out, const relationship_t &r)

YAML::Emitter &	operator<< (YAML::Emitter &out, const access_t &r)

YAML::Emitter &	operator<< (YAML::Emitter &out, const diagram_t &d)

YAML::Emitter &	operator<< (YAML::Emitter &out, const module_access_t &a)

template<>
bool	check_diagram_type< include_diagram::model::diagram > (diagram_t t)

template<>
bool	check_diagram_type< clanguml::include_diagram::model::diagram > (diagram_t t)

template<>
bool	check_diagram_type< clanguml::package_diagram::model::diagram > (diagram_t t)

template<>
bool	check_diagram_type< clanguml::package_diagram::model::diagram > (diagram_t t)

template<>
bool	check_diagram_type< clanguml::sequence_diagram::model::diagram > (diagram_t t)

template<>
bool	check_diagram_type< clanguml::sequence_diagram::model::diagram > (diagram_t t)

Typedef Documentation

◆ class_dependants_filter_t

using clanguml::common::model::class_dependants_filter_t = typedef edge_traversal_filter<class_diagram::model::diagram, class_diagram::model::class_, common::string_or_regex>

Definition at line 28 of file diagram_filter_factory.h.

◆ class_dependencies_filter_t

using clanguml::common::model::class_dependencies_filter_t = typedef edge_traversal_filter<class_diagram::model::diagram, class_diagram::model::class_, common::string_or_regex>

Definition at line 31 of file diagram_filter_factory.h.

◆ comment_t

using clanguml::common::model::comment_t = typedef inja::json

Definition at line 35 of file decorated_element.h.

◆ filesystem_path

using clanguml::common::model::filesystem_path = typedef common::model::path

Definition at line 56 of file source_file.h.

◆ namespace_

using clanguml::common::model::namespace_ = typedef path

Definition at line 32 of file namespace.h.

◆ package_dependants_filter_t

using clanguml::common::model::package_dependants_filter_t = typedef edge_traversal_filter<package_diagram::model::diagram, common::model::package, common::string_or_regex>

Definition at line 35 of file diagram_filter_factory.h.

◆ package_dependencies_filter_t

using clanguml::common::model::package_dependencies_filter_t = typedef edge_traversal_filter<package_diagram::model::diagram, common::model::package, common::string_or_regex>

Definition at line 38 of file diagram_filter_factory.h.

◆ source_file_dependency_filter_t

using clanguml::common::model::source_file_dependency_filter_t = typedef edge_traversal_filter<include_diagram::model::diagram, common::model::source_file, std::string, common::model::source_file>

Definition at line 42 of file diagram_filter_factory.h.

◆ specializations_filter_t

using clanguml::common::model::specializations_filter_t = typedef edge_traversal_filter<class_diagram::model::diagram, class_diagram::model::class_, common::string_or_regex>

Definition at line 24 of file diagram_filter_factory.h.

Enumeration Type Documentation

◆ access_t

enum class clanguml::common::model::access_t

strong

Enumerator
kPublic
kProtected
kPrivate
kNone

Definition at line 29 of file enums.h.

29{ kPublic, kProtected, kPrivate, kNone };

◆ diagram_t

enum class clanguml::common::model::diagram_t

strong

Enumerator
kClass
kSequence
kPackage
kInclude

Definition at line 26 of file enums.h.

26{ kClass, kSequence, kPackage, kInclude };

◆ filter_t

enum class clanguml::common::model::filter_t

strong

Diagram filters can be add in 2 modes:

inclusive - the elements that match are included in the diagram
exclusive - the elements that match are excluded from the diagram

Enumerator
kInclusive	Filter is inclusive
kExclusive	Filter is exclusve

Definition at line 50 of file diagram_filter.h.

                    {
    kInclusive, /*!< Filter is inclusive */
    kExclusive  /*!< Filter is exclusve */
};

◆ message_scope_t

enum class clanguml::common::model::message_scope_t

strong

The scope of the call expression represented in the sequence diagram.

Enumerator
kNormal
kCondition

Definition at line 73 of file enums.h.

                           {
    kNormal,   // This is a regular call expression
    kCondition // This is a call expression from within a control condition
               // e.g if(a->is_valid()) { ... }
};

◆ message_t

enum class clanguml::common::model::message_t

strong

Types of sequence diagram activity elements.

Enumerator
kCall
kReturn
kIf
kElse
kElseIf
kIfEnd
kWhile
kWhileEnd
kDo
kDoEnd
kFor
kForEnd
kTry
kCatch
kTryEnd
kSwitch
kCase
kSwitchEnd
kConditional
kConditionalElse
kConditionalEnd
kNone

Definition at line 47 of file enums.h.

                     {
    kCall,
    kReturn,
    kIf,
    kElse,
    kElseIf,
    kIfEnd,
    kWhile,
    kWhileEnd,
    kDo,
    kDoEnd,
    kFor,
    kForEnd,
    kTry,
    kCatch,
    kTryEnd,
    kSwitch,
    kCase,
    kSwitchEnd,
    kConditional,
    kConditionalElse,
    kConditionalEnd,
    kNone
};

◆ module_access_t

enum class clanguml::common::model::module_access_t

strong

Enumerator
kPublic
kPrivate

Definition at line 28 of file enums.h.

28{ kPublic, kPrivate };

◆ path_type

enum class clanguml::common::model::path_type

strong

Type of diagram path.

Paths in diagrams represent the nest structure within a diagram, e.g. a nested set of namespaces or nested set of directories.

Enumerator
kNamespace	Namespace path
kFilesystem	Filesystem path
kModule	Module path

Definition at line 34 of file path.h.

                     {
    kNamespace,  /*!< Namespace path */
    kFilesystem, /*!< Filesystem path */
    kModule      /*!< Module path */
};

◆ relationship_t

enum class clanguml::common::model::relationship_t

strong

Enumerator
kNone
kExtension
kComposition
kAggregation
kContainment
kOwnership
kAssociation
kInstantiation
kFriendship
kAlias
kDependency
kConstraint

Definition at line 31 of file enums.h.

                          {
    kNone,
    kExtension,
    kComposition,
    kAggregation,
    kContainment,
    kOwnership,
    kAssociation,
    kInstantiation,
    kFriendship,
    kAlias,
    kDependency,
    kConstraint
};

◆ rpqualifier

enum class clanguml::common::model::rpqualifier

strong

Enum representing type of reference or pointer type qualifier

Enumerator
kLValueReference	l-value reference (e.g. &)
kRValueReference	r-value reference (e.g. &&)
kPointer	pointer (e.g *)
kNone	No qualifier

Definition at line 57 of file template_parameter.h.

                       {
    kLValueReference, /*!< l-value reference (e.g. &) */
    kRValueReference, /*!< r-value reference (e.g. &&) */
    kPointer,         /*!< pointer (e.g *) */
    kNone             /*!< No qualifier */
};

◆ source_file_t

enum class clanguml::common::model::source_file_t

strong

This enum represents different kinds of files in the diagram.

Enumerator
kDirectory	Diagram element is a directory
kHeader	Diagram element is a header
kImplementation	Diagram element is a source file (e.g. cpp)

Definition at line 40 of file source_file.h.

                         {
    kDirectory,     /*!< Diagram element is a directory */
    kHeader,        /*!< Diagram element is a header */
    kImplementation /*!< Diagram element is a source file (e.g. cpp) */
};

◆ template_parameter_kind_t

enum class clanguml::common::model::template_parameter_kind_t

strong

Type of template parameter or argument.

Enumerator
template_type	Template type, e.g. <typename T>
template_template_type	Template template type, e.g. <typename <> T>
non_type_template	Non type template parameter, e.g. <int N>
argument	Template argument, e.g. <int>
concept_constraint	Concept constraint, e.g. <std::integral T>
empty	Represent empty template specialization

Definition at line 43 of file template_parameter.h.

                                     {
    template_type,          /*!< Template type, e.g. <typename T> */
    template_template_type, /*!< Template template type, e.g. <typename <> T> */
    non_type_template,      /*!< Non type template parameter, e.g. <int N> */
    argument,               /*!< Template argument, e.g. <int> */
    concept_constraint,     /*!< Concept constraint, e.g. <std::integral T> */
    empty                   /*!< Represent empty template specialization */
};

Function Documentation

◆ apply_filter() [1/2]

template<typename Collection >

void clanguml::common::model::apply_filter	(	Collection &	col,
		const diagram_filter &	filter
	)

Definition at line 856 of file diagram_filter.h.

{
    col.erase(std::remove_if(col.begin(), col.end(),
                  [&filter](auto &&element) {
                      return !filter.should_include(element);
                  }),
        col.end());
}

◆ apply_filter() [2/2]

template<typename T >

void clanguml::common::model::apply_filter	(	std::vector< std::reference_wrapper< T > > &	col,
		const diagram_filter &	filter
	)

Definition at line 866 of file diagram_filter.h.

{
    col.erase(std::remove_if(col.begin(), col.end(),
                  [&filter](auto &&element) {
                      return !filter.should_include(element.get());
                  }),
        col.end());
}

◆ calculate_template_params_specialization_match()

int clanguml::common::model::calculate_template_params_specialization_match	(	const std::vector< template_parameter > &	specialization,
		const std::vector< template_parameter > &	base_template
	)

Calculate the match between 2 template parameter lists.

The higher the value, the more likely it is that *this is a specialization of base_template_parameter.

Todo:: This is not scientific - there probably is more strict way to calculate this...

Parameters

base_template_parameter

Returns: Specialization match value

Definition at line 646 of file template_parameter.cc.

{
    int res{0};
 
    if (specialization_params.size() != template_params.size() &&
        !std::any_of(template_params.begin(), template_params.end(),
            [](const auto &t) { return t.is_variadic(); })) {
        return 0;
    }
 
    if (!specialization_params.empty() && !template_params.empty()) {
        auto template_index{0U};
        auto arg_index{0U};
 
        while (arg_index < specialization_params.size() &&
            template_index < template_params.size()) {
            auto match = specialization_params.at(arg_index)
                             .calculate_specialization_match(
                                 template_params.at(template_index));
 
            if (match == 0) {
                // If any of the matches is 0 - the entire match fails
                return 0;
            }
 
            // Add 1 point if the current specialization param is an argument
            // as it's a more specific match than 2 template params
            if (!specialization_params.at(arg_index).is_template_parameter())
                res++;
 
            // Add 1 point if the current template param is an argument
            // as it's a more specific match than 2 template params
            if (!template_params.at(template_index).is_template_parameter())
                res++;
 
            if (!template_params.at(template_index).is_variadic())
                template_index++;
 
            res += match;
 
            arg_index++;
        }
 
        if (arg_index == specialization_params.size()) {
            // Check also backwards to make sure that trailing non-variadic
            // params match after a variadic parameter
            template_index = template_params.size() - 1;
            arg_index = specialization_params.size() - 1;
 
            while (true) {
                auto match = specialization_params.at(arg_index)
                                 .calculate_specialization_match(
                                     template_params.at(template_index));
                if (match == 0) {
                    return 0;
                }
 
                if (arg_index == 0 || template_index == 0)
                    break;
 
                arg_index--;
 
                if (!template_params.at(template_index).is_variadic())
                    template_index--;
                else
                    break;
            }
 
            return res;
        }
 
        return 0;
    }
 
    return 0;
}

◆ check_diagram_type()

template<typename DiagramT >

bool clanguml::common::model::check_diagram_type ( diagram_t t )

◆ check_diagram_type< clanguml::class_diagram::model::diagram >() [1/2]

template<>

bool clanguml::common::model::check_diagram_type< clanguml::class_diagram::model::diagram > ( diagram_t t )

Definition at line 304 of file diagram.cc.

{
    return t == diagram_t::kClass;
}

◆ check_diagram_type< clanguml::class_diagram::model::diagram >() [2/2]

template<>

bool clanguml::common::model::check_diagram_type< clanguml::class_diagram::model::diagram > ( diagram_t t )

Definition at line 304 of file diagram.cc.

{
    return t == diagram_t::kClass;
}

◆ check_diagram_type< clanguml::include_diagram::model::diagram >()

template<>

bool clanguml::common::model::check_diagram_type< clanguml::include_diagram::model::diagram > ( diagram_t t )

◆ check_diagram_type< clanguml::package_diagram::model::diagram >() [1/2]

template<>

bool clanguml::common::model::check_diagram_type< clanguml::package_diagram::model::diagram > ( diagram_t t )

Definition at line 96 of file diagram.cc.

{
    return t == diagram_t::kPackage;
}

◆ check_diagram_type< clanguml::package_diagram::model::diagram >() [2/2]

template<>

bool clanguml::common::model::check_diagram_type< clanguml::package_diagram::model::diagram > ( diagram_t t )

Definition at line 96 of file diagram.cc.

{
    return t == diagram_t::kPackage;
}

◆ check_diagram_type< clanguml::sequence_diagram::model::diagram >() [1/2]

template<>

bool clanguml::common::model::check_diagram_type< clanguml::sequence_diagram::model::diagram > ( diagram_t t )

Definition at line 708 of file diagram.cc.

{
    return t == diagram_t::kSequence;
}

◆ check_diagram_type< clanguml::sequence_diagram::model::diagram >() [2/2]

template<>

bool clanguml::common::model::check_diagram_type< clanguml::sequence_diagram::model::diagram > ( diagram_t t )

Definition at line 708 of file diagram.cc.

{
    return t == diagram_t::kSequence;
}

◆ check_diagram_type< include_diagram::model::diagram >()

template<>

bool clanguml::common::model::check_diagram_type< include_diagram::model::diagram > ( diagram_t t )

Definition at line 143 of file diagram.cc.

{
    return t == diagram_t::kInclude;
}

◆ diagram_filter::should_include< std::string >() [1/2]

template<>

bool clanguml::common::model::diagram_filter::should_include< std::string > ( const std::string & name ) const

Definition at line 1390 of file diagram_filter.cc.

{
    if (name.empty())
        return false;
 
    auto [ns, n] = common::split_ns(name);
 
    return should_include(ns, n);
}

◆ diagram_filter::should_include< std::string >() [2/2]

template<>

bool clanguml::common::model::diagram_filter::should_include< std::string > ( const std::string & name ) const

Definition at line 1390 of file diagram_filter.cc.

{
    if (name.empty())
        return false;
 
    auto [ns, n] = common::split_ns(name);
 
    return should_include(ns, n);
}

◆ from_string()

diagram_t clanguml::common::model::from_string ( const std::string & s )

Definition at line 169 of file enums.cc.

{
    if (s == "class")
        return diagram_t::kClass;
    if (s == "sequence")
        return diagram_t::kSequence;
    if (s == "include")
        return diagram_t::kInclude;
    if (s == "package")
        return diagram_t::kPackage;
 
    throw std::runtime_error{"Invalid diagram type: " + s};
}

◆ needs_root_prefix()

template<typename T >

bool clanguml::common::model::needs_root_prefix ( const T & e )

Definition at line 176 of file diagram.h.

{
    if (e.get_namespace().type() != model::path_type::kNamespace)
        return false;
 
    if (e.using_namespace().is_empty())
        return false;
 
    return !util::starts_with(
        e.full_name(false), e.using_namespace().to_string());
}

◆ operator<<() [1/3]

std::ostream & clanguml::common::model::operator<<	(	std::ostream &	out,
		const diagram_element &	rhs
	)

Definition at line 123 of file diagram_element.cc.

{
    out << "(" << rhs.name() << ", full_name=[" << rhs.full_name(false) << "])";
 
    return out;
}

◆ operator<<() [2/3]

std::ostream & clanguml::common::model::operator<<	(	std::ostream &	out,
		const element &	rhs
	)

Definition at line 42 of file element.cc.

{
    out << "(" << rhs.name() << ", ns=[" << rhs.get_namespace().to_string()
        << "], full_name=[" << rhs.full_name(true) << "])";
 
    return out;
}

◆ operator<<() [3/3]

YAML::Emitter & clanguml::common::model::operator<<	(	YAML::Emitter &	out,
		const module_access_t &	a
	)

Definition at line 72 of file yaml_emitters.cc.

{
    out << to_string(a);
    return out;
}

◆ operator==() [1/3]

bool clanguml::common::model::operator==	(	const diagram_element &	l,
		const diagram_element &	r
	)

Definition at line 118 of file diagram_element.cc.

{
    return l.id() == r.id();
}

◆ operator==() [2/3]

bool clanguml::common::model::operator==	(	const element &	l,
		const element &	r
	)

Definition at line 36 of file element.cc.

{
    return (l.type_name() == l.type_name()) &&
        (l.full_name(false) == r.full_name(false));
}

◆ operator==() [3/3]

bool clanguml::common::model::operator==	(	const relationship &	l,
		const relationship &	r
	)

Definition at line 93 of file relationship.cc.

{
    return l.type() == r.type() && l.destination() == r.destination() &&
        l.label() == r.label();
}

◆ to_json() [1/8]

void clanguml::common::model::to_json	(	json &	j,
		const element &	c
	)

◆ to_json() [2/8]

void clanguml::common::model::to_json	(	json &	j,
		const relationship &	c
	)

◆ to_json() [3/8]

void clanguml::common::model::to_json	(	json &	j,
		const source_location &	sl
	)

◆ to_json() [4/8]

void clanguml::common::model::to_json	(	json &	j,
		const template_parameter &	c
	)

◆ to_json() [5/8]

void clanguml::common::model::to_json	(	nlohmann::json &	j,
		const element &	c
	)

Definition at line 34 of file generator.cc.

{
    j = json{{"id", std::to_string(c.id().value())}, {"name", c.name()},
        {"namespace", c.get_namespace().to_string()}, {"type", c.type_name()},
        {"display_name", display_name_adapter(c).full_name(true)}};
 
    if (const auto &comment = c.comment(); comment)
        j["comment"] = comment.value();
 
    if (!c.file().empty()) {
        j["source_location"] =
            dynamic_cast<const common::model::source_location &>(c);
    }
}

◆ to_json() [6/8]

void clanguml::common::model::to_json	(	nlohmann::json &	j,
		const relationship &	c
	)

Definition at line 62 of file generator.cc.

{
    j["type"] = to_string(c.type());
    j["destination"] = std::to_string(c.destination().value());
    if (!c.multiplicity_source().empty())
        j["multiplicity_source"] = c.multiplicity_source();
    if (!c.multiplicity_destination().empty())
        j["multiplicity_destination"] = c.multiplicity_destination();
    if (c.access() != access_t::kNone)
        j["access"] = to_string(c.access());
    if (!c.label().empty())
        j["label"] = c.label();
    if (const auto &comment = c.comment(); comment)
        j["comment"] = comment.value();
}

◆ to_json() [7/8]

void clanguml::common::model::to_json	(	nlohmann::json &	j,
		const source_location &	sl
	)

Definition at line 27 of file generator.cc.

{
    j = json{{"file", sl.file_relative()},
        {"translation_unit", sl.translation_unit()}, {"line", sl.line()},
        {"column", sl.column()}};
}

◆ to_json() [8/8]

void clanguml::common::model::to_json	(	nlohmann::json &	j,
		const template_parameter &	c
	)

Definition at line 49 of file generator.cc.

{
    j["kind"] = to_string(c.kind());
    if (const auto &t = c.type(); t)
        j["type"] = t.value();
    if (const auto &n = c.name(); n)
        j["name"] = n.value();
    if (const auto &d = c.default_value(); d)
        j["default"] = d.value();
    j["is_variadic"] = c.is_variadic();
    j["template_parameters"] = c.template_params();
}

◆ to_string() [1/9]

std::string clanguml::common::model::to_string ( access_t a )

Definition at line 58 of file enums.cc.

{
    switch (a) {
    case access_t::kPublic:
        return "public";
    case access_t::kProtected:
        return "protected";
    case access_t::kPrivate:
        return "private";
    case access_t::kNone:
        return "none";
    default:
        assert(false);
        return "";
    }
}

◆ to_string() [2/9]

std::string clanguml::common::model::to_string ( const diagram_t t )

Definition at line 139 of file enums.cc.

{
    switch (t) {
    case diagram_t::kClass:
        return "class";
    case diagram_t::kSequence:
        return "sequence";
    case diagram_t::kPackage:
        return "package";
    case diagram_t::kInclude:
        return "include";
    default:
        assert(false);
        return "";
    }
}

◆ to_string() [3/9]

std::string clanguml::common::model::to_string ( const message_scope_t t )

Definition at line 156 of file enums.cc.

{
    switch (t) {
    case message_scope_t::kNormal:
        return "normal";
    case message_scope_t::kCondition:
        return "condition";
    default:
        assert(false);
        return "";
    }
}

◆ to_string() [4/9]

std::string clanguml::common::model::to_string ( const path_type pt )

Definition at line 23 of file path.cc.

{
    switch (pt) {
    case path_type::kModule:
        return "module";
    case path_type::kNamespace:
        return "namespace";
    case path_type::kFilesystem:
        return "directory";
    default:
        assert(false);
        return "";
    }
}

◆ to_string() [5/9]

std::string clanguml::common::model::to_string ( message_t r )

Definition at line 88 of file enums.cc.

{
    switch (r) {
    case message_t::kCall:
        return "call";
    case message_t::kReturn:
        return "return";
    case message_t::kIf:
        return "if";
    case message_t::kElse:
        return "else";
    case message_t::kElseIf:
        return "else if";
    case message_t::kIfEnd:
        return "end if";
    case message_t::kWhile:
        return "while";
    case message_t::kWhileEnd:
        return "end while";
    case message_t::kDo:
        return "do";
    case message_t::kDoEnd:
        return "end do";
    case message_t::kFor:
        return "for";
    case message_t::kForEnd:
        return "end for";
    case message_t::kTry:
        return "try";
    case message_t::kCatch:
        return "catch";
    case message_t::kTryEnd:
        return "end try";
    case message_t::kSwitch:
        return "switch";
    case message_t::kCase:
        return "case";
    case message_t::kSwitchEnd:
        return "end switch";
    case message_t::kConditional:
        return "conditional";
    case message_t::kConditionalElse:
        return "conditional else";
    case message_t::kConditionalEnd:
        return "end conditional";
    default:
        assert(false);
        return "";
    }
}

◆ to_string() [6/9]

std::string clanguml::common::model::to_string ( module_access_t a )

Definition at line 75 of file enums.cc.

{
    switch (a) {
    case module_access_t::kPublic:
        return "public";
    case module_access_t::kPrivate:
        return "private";
    default:
        assert(false);
        return "";
    }
}

◆ to_string() [7/9]

std::string clanguml::common::model::to_string ( relationship_t r )

Definition at line 25 of file enums.cc.

{
    switch (r) {
    case relationship_t::kNone:
        return "none";
    case relationship_t::kExtension:
        return "extension";
    case relationship_t::kComposition:
        return "composition";
    case relationship_t::kAggregation:
        return "aggregation";
    case relationship_t::kContainment:
        return "containment";
    case relationship_t::kOwnership:
        return "ownership";
    case relationship_t::kAssociation:
        return "association";
    case relationship_t::kInstantiation:
        return "instantiation";
    case relationship_t::kFriendship:
        return "friendship";
    case relationship_t::kDependency:
        return "dependency";
    case relationship_t::kAlias:
        return "alias";
    case relationship_t::kConstraint:
        return "constraint";
    default:
        assert(false);
        return "";
    }
}

◆ to_string() [8/9]

std::string clanguml::common::model::to_string ( source_file_t sf )

Definition at line 23 of file source_file.cc.

{
    switch (sf) {
    case source_file_t::kDirectory:
        return "directory";
    case source_file_t::kHeader:
        return "header";
    case source_file_t::kImplementation:
        return "implementation";
    default:
        assert(false);
        return "";
    }
}

◆ to_string() [9/9]

std::string clanguml::common::model::to_string ( template_parameter_kind_t k )

Definition at line 61 of file template_parameter.cc.

{
    switch (k) {
    case template_parameter_kind_t::template_type:
        return "template_type";
    case template_parameter_kind_t::template_template_type:
        return "template_template_type";
    case template_parameter_kind_t::non_type_template:
        return "non_type_template";
    case template_parameter_kind_t::argument:
        return "argument";
    case template_parameter_kind_t::concept_constraint:
        return "concept_constraint";
    case template_parameter_kind_t::empty:
        return "empty";
    default:
        assert(false);
        return "";
    }
}

Detailed Description

Namespaces

Classes

Typedefs

Enumerations

Functions

Typedef Documentation

◆ class_dependants_filter_t

◆ class_dependencies_filter_t

◆ comment_t

◆ filesystem_path

◆ namespace_

◆ package_dependants_filter_t

◆ package_dependencies_filter_t

◆ source_file_dependency_filter_t

◆ specializations_filter_t

Enumeration Type Documentation

◆ access_t

◆ diagram_t

◆ filter_t

◆ message_scope_t

◆ message_t

◆ module_access_t

◆ path_type

◆ relationship_t

◆ rpqualifier

◆ source_file_t

◆ template_parameter_kind_t

Function Documentation

◆ apply_filter() [1/2]

◆ apply_filter() [2/2]

◆ calculate_template_params_specialization_match()

◆ check_diagram_type()

◆ check_diagram_type< clanguml::class_diagram::model::diagram >() [1/2]

◆ check_diagram_type< clanguml::class_diagram::model::diagram >() [2/2]

◆ check_diagram_type< clanguml::include_diagram::model::diagram >()

◆ check_diagram_type< clanguml::package_diagram::model::diagram >() [1/2]

◆ check_diagram_type< clanguml::package_diagram::model::diagram >() [2/2]

◆ check_diagram_type< clanguml::sequence_diagram::model::diagram >() [1/2]

◆ check_diagram_type< clanguml::sequence_diagram::model::diagram >() [2/2]

◆ check_diagram_type< include_diagram::model::diagram >()

◆ diagram_filter::should_include< std::string >() [1/2]

◆ diagram_filter::should_include< std::string >() [2/2]

◆ from_string()

◆ needs_root_prefix()

◆ operator<<() [1/3]

◆ operator<<() [2/3]

◆ operator<<() [3/3]

◆ operator==() [1/3]

◆ operator==() [2/3]

◆ operator==() [3/3]

◆ to_json() [1/8]

◆ to_json() [2/8]

◆ to_json() [3/8]

◆ to_json() [4/8]

◆ to_json() [5/8]

◆ to_json() [6/8]

◆ to_json() [7/8]

◆ to_json() [8/8]

◆ to_string() [1/9]

◆ to_string() [2/9]

◆ to_string() [3/9]

◆ to_string() [4/9]

◆ to_string() [5/9]

◆ to_string() [6/9]

◆ to_string() [7/9]

◆ to_string() [8/9]

◆ to_string() [9/9]