clanguml::common Namespace Reference

Detailed Description

This namespace provides common interfaces for all kinds of diagrams.

The core diagram functionality is divided into 3 groups: visitor, model and generators.

Namespaces
namespace	generators
namespace	jinja
namespace	model
namespace	visitor

Classes
class	compilation_database
	Custom compilation database class. More...
class	eid_t
	Universal class for representing all kinds of Id's in the diagram model. More...
class	optional_ref
	Simple optional reference type. More...
struct	or_regex
	Convenience class for configuration options with regex support. More...
struct	path_or_regex
struct	regex
	Wrapper around std::regex, which contains original pattern. More...

Typedefs
using	compilation_database_ptr = std::unique_ptr< compilation_database >
template<typename T >
using	opt_ref = optional_ref< T >
template<typename T >
using	reference_vector = std::vector< std::reference_wrapper< T > >
template<typename T >
using	reference_set = std::unordered_set< std::reference_wrapper< T > >
using	string_or_regex = or_regex< std::string >
using	namespace_or_regex = common::or_regex< common::model::namespace_ >

Enumerations
enum class	generator_type_t { plantuml , json , mermaid , graphml }

Functions
model::access_t	access_specifier_to_access_t (clang::AccessSpecifier access_specifier)
	Convert clang::AccessSpecifier to.
model::access_t	access_specifier_to_access_t (clang::ObjCIvarDecl::AccessControl access_specifier)
model::namespace_	get_tag_namespace (const clang::TagDecl &declaration)
model::namespace_	get_template_namespace (const clang::TemplateDecl &declaration)
std::string	get_tag_name (const clang::TagDecl &declaration)
	Generate full qualified name for clang::TagDecl instance.
std::string	to_string (const clang::ArrayType &array_type, const clang::ASTContext &ctx, bool try_canonical, std::vector< std::string > &dimensions)
std::string	to_string (const clang::TemplateArgumentLoc &argLoc, const clang::ASTContext &context)
std::string	to_string (const clang::QualType &type, const clang::ASTContext &ctx, bool try_canonical)
std::string	to_string (const clang::RecordType &type, const clang::ASTContext &ctx, bool try_canonical)
std::string	to_string (const clang::TemplateArgument &arg, const clang::ASTContext *ctx)
std::string	to_string (const clang::TemplateName &templ)
std::string	to_string (const clang::Expr *expr)
std::string	to_string (const clang::ValueDecl *val)
std::string	to_string (const clang::Stmt *stmt)
std::string	to_string (const clang::FunctionTemplateDecl *decl)
std::string	to_string (const clang::TypeConstraint *tc)
std::string	get_source_text_raw (clang::SourceRange range, const clang::SourceManager &sm)
	Get raw text of specific source range.
std::string	get_source_text (clang::SourceRange range, const clang::SourceManager &sm)
	Get printable range of text of specific source range.
std::tuple< unsigned int, unsigned int, std::string >	extract_template_parameter_index (const std::string &type_parameter)
	Extract template depth and index.
void	ensure_lambda_type_is_relative (const config::diagram &config, std::string &parameter_type)
bool	is_subexpr_of (const clang::Stmt *parent_stmt, const clang::Stmt *sub_stmt)
	Check if an expression is contained in another expression.
template<>
eid_t	to_id (const std::string &full_name)
eid_t	to_id (const clang::QualType &type, const clang::ASTContext &ctx)
template<>
eid_t	to_id (const clang::NamespaceDecl &declaration)
template<>
eid_t	to_id (const clang::RecordDecl &declaration)
template<>
eid_t	to_id (const clang::ObjCCategoryDecl &type)
template<>
eid_t	to_id (const clang::ObjCInterfaceDecl &type)
template<>
eid_t	to_id (const clang::ObjCProtocolDecl &type)
template<>
eid_t	to_id (const clang::EnumDecl &declaration)
template<>
eid_t	to_id (const clang::TagDecl &declaration)
template<>
eid_t	to_id (const clang::CXXRecordDecl &declaration)
template<>
eid_t	to_id (const clang::EnumType &t)
template<>
eid_t	to_id (const std::filesystem::path &file)
template<>
eid_t	to_id (const clang::TemplateArgument &template_argument)
std::pair< common::model::namespace_, std::string >	split_ns (const std::string &full_name)
	Split qualified name to namespace and name.
std::vector< common::model::template_parameter >	parse_unexposed_template_params (const std::string &params, const std::function< std::string(const std::string &)> &ns_resolve, int depth=0)
	Parse unexposed (available as string) template params.
bool	is_type_parameter (const std::string &t)
bool	is_qualifier (const std::string &q)
bool	is_bracket (const std::string &b)
bool	is_identifier_character (char c)
bool	is_identifier (const std::string &t)
bool	is_keyword (const std::string &t)
bool	is_qualified_identifier (const std::string &t)
bool	is_type_token (const std::string &t)
std::string	format_condition_text (const std::string &condition_text)
std::string	get_condition_text (clang::SourceManager &sm, clang::IfStmt *stmt)
std::string	get_condition_text (clang::SourceManager &sm, clang::WhileStmt *stmt)
std::string	get_condition_text (clang::SourceManager &sm, clang::CXXForRangeStmt *stmt)
std::string	get_condition_text (clang::SourceManager &sm, clang::ForStmt *stmt)
std::string	get_condition_text (clang::SourceManager &sm, clang::DoStmt *stmt)
std::string	get_condition_text (clang::SourceManager &sm, clang::ConditionalOperator *stmt)
clang::QualType	dereference (clang::QualType type)
std::pair< clang::QualType, std::deque< common::model::context > >	consume_type_context (clang::QualType type)
	Extract type context and return raw type.
std::vector< std::string >	tokenize_unexposed_template_parameter (const std::string &t)
bool	parse_source_location (const std::string &location_str, std::string &file, unsigned &line, unsigned &column)
clang::RawComment *	get_expression_raw_comment (const clang::SourceManager &sm, const clang::ASTContext &context, const clang::Stmt *stmt)
	Extract a comment before or next to a statement.
clang::RawComment *	get_declaration_raw_comment (const clang::SourceManager &sm, const clang::ASTContext &context, const clang::Decl *decl)
clang::RawComment *	get_raw_comment (const clang::SourceManager &sm, const clang::ASTContext &context, const clang::SourceRange &source_range)
bool	is_coroutine (const clang::FunctionDecl &decl)
bool	is_struct (const clang::NamedDecl *decl)
bool	has_attr (const clang::FunctionDecl *decl, clang::attr::Kind function_attr)
std::optional< size_t >	get_array_size (const clang::ArrayType &type)
void	set_source_location (clang::SourceManager &source_manager, const clang::SourceLocation &location, clanguml::common::model::source_location &element, std::filesystem::path tu_path, std::filesystem::path relative_to_path_)
const clang::Type *	get_unqualified_type (const clang::TypedefDecl *decl)
const clang::EnumDecl *	get_typedef_enum_decl (const clang::TypedefDecl *decl)
bool	is_lambda_call (const clang::Expr *expr)
bool	is_lambda_method (const clang::FunctionDecl *decl)
template<typename T >
std::string	get_qualified_name (const T &declaration)
	Get qualified name of some Clang declaration.
template<typename T >
eid_t	to_id (const T &declaration)
template<>
eid_t	to_id (const std::string &full_name)
template<>
eid_t	to_id (const clang::NamespaceDecl &declaration)
template<>
eid_t	to_id (const clang::CXXRecordDecl &declaration)
template<>
eid_t	to_id (const clang::RecordDecl &declaration)
template<>
eid_t	to_id (const clang::ObjCCategoryDecl &type)
template<>
eid_t	to_id (const clang::ObjCInterfaceDecl &type)
template<>
eid_t	to_id (const clang::ObjCProtocolDecl &type)
template<>
eid_t	to_id (const clang::EnumDecl &declaration)
template<>
eid_t	to_id (const clang::TagDecl &declaration)
template<>
eid_t	to_id (const clang::EnumType &type)
template<>
eid_t	to_id (const clang::TemplateSpecializationType &type)
template<>
eid_t	to_id (const std::filesystem::path &type)
template<typename T , typename P , typename F >
void	if_dyn_cast (P pointer, F &&func)
bool	operator== (const eid_t &lhs, const eid_t &rhs)
bool	operator== (const eid_t &lhs, const uint64_t &v)
bool	operator!= (const eid_t &lhs, const uint64_t &v)
bool	operator!= (const eid_t &lhs, const eid_t &rhs)
bool	operator< (const eid_t &lhs, const eid_t &rhs)
std::string	to_string (const bool v)
std::string	to_string (const std::string &s)
std::string	to_string (const string_or_regex &sr)
std::string	to_string (const std::filesystem::path &p)
std::string	to_string (const generator_type_t type)
YAML::Emitter &	operator<< (YAML::Emitter &out, const string_or_regex &m)

Typedef Documentation

compilation_database_ptr

using clanguml::common::compilation_database_ptr = typedef std::unique_ptr<compilation_database>

Definition at line 143 of file compilation_database.h.

namespace_or_regex

using clanguml::common::namespace_or_regex = typedef common::or_regex<common::model::namespace_>

Definition at line 347 of file types.h.

opt_ref

template<typename T >

using clanguml::common::opt_ref = typedef optional_ref<T>

Definition at line 229 of file types.h.

reference_set

template<typename T >

using clanguml::common::reference_set = typedef std::unordered_set<std::reference_wrapper<T> >

Definition at line 235 of file types.h.

reference_vector

template<typename T >

using clanguml::common::reference_vector = typedef std::vector<std::reference_wrapper<T> >

Definition at line 232 of file types.h.

string_or_regex

using clanguml::common::string_or_regex = typedef or_regex<std::string>

Definition at line 343 of file types.h.

Enumeration Type Documentation

generator_type_t

enum class clanguml::common::generator_type_t

strong

Type of output diagram format generator.

Enumerator
plantuml	Diagrams will be generated in PlantUML format
json	Diagrams will be generated in JSON format
mermaid	Diagrams will be generated in MermaidJS format
graphml	Diagrams will be generated in GraphML format

Definition at line 86 of file types.h.

                            {
    plantuml, /*!< Diagrams will be generated in PlantUML format */
    json,     /*!< Diagrams will be generated in JSON format */
    mermaid,  /*!< Diagrams will be generated in MermaidJS format */
    graphml   /*!< Diagrams will be generated in GraphML format */
};

Function Documentation

access_specifier_to_access_t() [1/2]

model::access_t clanguml::common::access_specifier_to_access_t

(

clang::AccessSpecifier

access_specifier

)

Convert clang::AccessSpecifier to.

See also

clanguml::model::access_t

Parameters

access_specifier

Clang member access specifier

Returns

Enum value of

See also

clanguml::model::access_t

Definition at line 25 of file clang_utils.cc.

{
    auto access = model::access_t::kPublic;
    switch (access_specifier) {
    case clang::AccessSpecifier::AS_public:
        access = model::access_t::kPublic;
        break;
    case clang::AccessSpecifier::AS_private:
        access = model::access_t::kPrivate;
        break;
    case clang::AccessSpecifier::AS_protected:
        access = model::access_t::kProtected;
        break;
    default:
        break;
    }
 
    return access;
}

access_specifier_to_access_t() [2/2]

model::access_t clanguml::common::access_specifier_to_access_t

(

clang::ObjCIvarDecl::AccessControl

access_specifier

)

Definition at line 46 of file clang_utils.cc.

{
    auto access = model::access_t::kPublic;
    switch (access_specifier) {
    case clang::ObjCIvarDecl::AccessControl::Public:
        access = model::access_t::kPublic;
        break;
    case clang::ObjCIvarDecl::AccessControl::Private:
        access = model::access_t::kPrivate;
        break;
    case clang::ObjCIvarDecl::AccessControl::Protected:
        access = model::access_t::kProtected;
        break;
    default:
        break;
    }
 
    return access;
}

consume_type_context()

std::pair< clang::QualType, std::deque< common::model::context > > clanguml::common::consume_type_context

(

clang::QualType

type

)

Extract type context and return raw type.

This function removes the context for a type, for example for: std::string const& it will return (std::string, [const&])

Parameters

type	Type to process

Returns

(type, [qualifiers])

Definition at line 792 of file clang_utils.cc.

{
    std::deque<common::model::context> res;
 
    while (true) {
        bool try_again{false};
        common::model::context ctx;
 
        if (type.isConstQualified()) {
            ctx.is_const = true;
            try_again = true;
        }
 
        if (type.isVolatileQualified()) {
            ctx.is_volatile = true;
            try_again = true;
        }
 
        if (type->isPointerType() || type->isReferenceType()) {
            if (type.isConstQualified() || type.isVolatileQualified()) {
                ctx.is_ref_const = type.isConstQualified();
                ctx.is_ref_volatile = type.isVolatileQualified();
 
                try_again = true;
            }
        }
 
        if (type->isLValueReferenceType()) {
            ctx.pr = common::model::rpqualifier::kLValueReference;
            try_again = true;
        }
        else if (type->isRValueReferenceType()) {
            ctx.pr = common::model::rpqualifier::kRValueReference;
            try_again = true;
        }
        else if (type->isMemberFunctionPointerType() &&
            type->getPointeeType()->getAs<clang::FunctionProtoType>() !=
                nullptr) {
            const auto ref_qualifier =
                type->getPointeeType()                  // NOLINT
                    ->getAs<clang::FunctionProtoType>() // NOLINT
                    ->getRefQualifier();
 
            if (ref_qualifier == clang::RefQualifierKind::RQ_RValue) {
                ctx.pr = common::model::rpqualifier::kRValueReference;
                try_again = true;
            }
            else if (ref_qualifier == clang::RefQualifierKind::RQ_LValue) {
                ctx.pr = common::model::rpqualifier::kLValueReference;
                try_again = true;
            }
        }
        else if (type->isPointerType()) {
            ctx.pr = common::model::rpqualifier::kPointer;
            try_again = true;
        }
 
        if (try_again) {
            if (type->isPointerType()) {
                if (type->getPointeeType().isConstQualified())
                    ctx.is_const = true;
                if (type->getPointeeType().isVolatileQualified())
                    ctx.is_volatile = true;
 
                type = type->getPointeeType().getUnqualifiedType();
            }
            else if (type->isReferenceType()) {
                if (type.getNonReferenceType().isConstQualified())
                    ctx.is_const = true;
                if (type.getNonReferenceType().isVolatileQualified())
                    ctx.is_volatile = true;
 
                type = type.getNonReferenceType().getUnqualifiedType();
            }
            else if (type.isConstQualified() || type.isVolatileQualified()) {
                ctx.is_const = type.isConstQualified();
                ctx.is_volatile = type.isVolatileQualified();
                type = type.getUnqualifiedType();
            }
 
            res.push_front(ctx);
 
            if (type->isMemberFunctionPointerType())
                return std::make_pair(type, res);
        }
        else
            return std::make_pair(type, res);
    }
}

dereference()

clang::QualType clanguml::common::dereference

(

clang::QualType

type

)

Definition at line 775 of file clang_utils.cc.

{
    auto res = type;
 
    while (true) {
        if (res->isReferenceType())
            res = res.getNonReferenceType();
        else if (res->isPointerType())
            res = res->getPointeeType();
        else
            break;
    }
 
    return res;
}

ensure_lambda_type_is_relative()

void clanguml::common::ensure_lambda_type_is_relative	(	const config::diagram &	config,
		std::string &	parameter_type
	)

Definition at line 418 of file clang_utils.cc.

{
#ifdef _MSC_VER
    auto root_name =
        fmt::format("{}", std::filesystem::current_path().root_name().string());
#else
    auto root_name = std::string{"/"};
#endif
 
    std::string lambda_prefix{fmt::format("(lambda at {}", root_name)};
 
    while (parameter_type.find(lambda_prefix) != std::string::npos) {
        auto lambda_begin = parameter_type.find(lambda_prefix);
        auto lambda_prefix_size = lambda_prefix.size();
#ifdef _MSC_VER
        // Skip the `\` or `/` after drive letter and semicolon
        lambda_prefix_size++;
#endif
        auto absolute_lambda_path_end =
            parameter_type.find(':', lambda_begin + lambda_prefix_size);
        auto absolute_lambda_path = parameter_type.substr(
            lambda_begin + lambda_prefix_size - 1,
            absolute_lambda_path_end - (lambda_begin + lambda_prefix_size - 1));
 
        auto relative_lambda_path = util::path_to_url(
            config.make_path_relative(absolute_lambda_path).string());
 
        parameter_type = fmt::format("{}(lambda at {}{}",
            parameter_type.substr(0, lambda_begin), relative_lambda_path,
            parameter_type.substr(absolute_lambda_path_end));
    }
}

extract_template_parameter_index()

std::tuple< unsigned int, unsigned int, std::string > clanguml::common::extract_template_parameter_index

(

const std::string &

type_parameter

)

Extract template depth and index.

This function extracts template depth and index values from Clang's type-parameter- names.

Parameters

type_parameter

Clang's type parameter string

Returns

(depth, index, qualifier)

Definition at line 399 of file clang_utils.cc.

{
    assert(type_parameter.find("type-parameter-") == 0);
 
    auto type_parameter_and_suffix = util::split(type_parameter, " ");
 
    auto toks = util::split(
        type_parameter_and_suffix.front().substr(strlen("type-parameter-")),
        "-");
 
    std::string qualifier;
 
    if (type_parameter_and_suffix.size() > 1) {
        qualifier = type_parameter_and_suffix.at(1);
    }
 
    return {std::stoi(toks.at(0)), std::stoi(toks.at(1)), std::move(qualifier)};
}

format_condition_text()

std::string clanguml::common::format_condition_text

(

const std::string &

condition_text

)

Definition at line 706 of file clang_utils.cc.

{
    std::string result{condition_text};
 
    if (result.size() < 2)
        return {};
 
    std::vector<std::string> text_lines = util::split(result, "\n", true);
 
    // Trim each line
    for (auto &line : text_lines) {
        line = util::trim(line);
    }
 
    result = util::join(" ", text_lines);
 
    if (result.at(0) == '(' && result.back() == ')')
        return result.substr(1, result.size() - 2);
 
    return result;
}

get_array_size()

std::optional< size_t > clanguml::common::get_array_size

(

const clang::ArrayType &

type

)

If type is a constant array, return it's number of elements. Otherwise nothing.

Parameters

type

Returns

Number of elements in the array.

Definition at line 1070 of file clang_utils.cc.

{
    if (const auto *constant_array =
            clang::dyn_cast<clang::ConstantArrayType>(&type);
        constant_array != nullptr) {
        return {constant_array->getSize().getZExtValue()};
    }
 
    return {};
}

get_condition_text() [1/6]

std::string clanguml::common::get_condition_text	(	clang::SourceManager &	sm,
		clang::ConditionalOperator *	stmt
	)

Definition at line 767 of file clang_utils.cc.

{
    auto condition_range = stmt->getCond()->getSourceRange();
 
    return format_condition_text(get_source_text(condition_range, sm));
}

get_condition_text() [2/6]

std::string clanguml::common::get_condition_text	(	clang::SourceManager &	sm,
		clang::CXXForRangeStmt *	stmt
	)

Definition at line 744 of file clang_utils.cc.

{
    auto condition_range = stmt->getRangeStmt()->getSourceRange();
 
    return format_condition_text(get_source_text(condition_range, sm));
}

get_condition_text() [3/6]

std::string clanguml::common::get_condition_text	(	clang::SourceManager &	sm,
		clang::DoStmt *	stmt
	)

Definition at line 760 of file clang_utils.cc.

{
    auto condition_range = stmt->getCond()->getSourceRange();
 
    return format_condition_text(get_source_text(condition_range, sm));
}

get_condition_text() [4/6]

std::string clanguml::common::get_condition_text	(	clang::SourceManager &	sm,
		clang::ForStmt *	stmt
	)

Definition at line 752 of file clang_utils.cc.

{
    auto condition_range =
        clang::SourceRange(stmt->getLParenLoc(), stmt->getRParenLoc());
 
    return format_condition_text(get_source_text(condition_range, sm));
}

get_condition_text() [5/6]

std::string clanguml::common::get_condition_text	(	clang::SourceManager &	sm,
		clang::IfStmt *	stmt
	)

Definition at line 728 of file clang_utils.cc.

{
    auto condition_range =
        clang::SourceRange(stmt->getLParenLoc(), stmt->getRParenLoc());
 
    return format_condition_text(get_source_text(condition_range, sm));
}

get_condition_text() [6/6]

std::string clanguml::common::get_condition_text	(	clang::SourceManager &	sm,
		clang::WhileStmt *	stmt
	)

Definition at line 736 of file clang_utils.cc.

{
    auto condition_range =
        clang::SourceRange(stmt->getLParenLoc(), stmt->getRParenLoc());
 
    return format_condition_text(get_source_text(condition_range, sm));
}

get_declaration_raw_comment()

clang::RawComment * clanguml::common::get_declaration_raw_comment	(	const clang::SourceManager &	sm,
		const clang::ASTContext &	context,
		const clang::Decl *	decl
	)

Definition at line 1008 of file clang_utils.cc.

{
    return get_raw_comment(sm, context, decl->getSourceRange());
}

get_expression_raw_comment()

clang::RawComment * clanguml::common::get_expression_raw_comment	(	const clang::SourceManager &	sm,
		const clang::ASTContext &	context,
		const clang::Stmt *	stmt
	)

Extract a comment before or next to a statement.

Parameters

sm	clang::SourceManager reference
context	clang::ASTContext reference
stmt	Pointer to the current clang::Stmt

Returns

Pointer to a clang::RawComment* or nullptr

Definition at line 1002 of file clang_utils.cc.

{
    return get_raw_comment(sm, context, stmt->getSourceRange());
}

get_qualified_name()

template<typename T >

std::string clanguml::common::get_qualified_name

(

const T &

declaration

)

Get qualified name of some Clang declaration.

This template is convenient for getting qualified name of various types of clang declarations.

Template Parameters

T	Type of Clang's declaration, e.g. clang::TagDecl

Parameters

declaration

Reference to a clang declaration

Returns

Fully qualified name

Definition at line 71 of file clang_utils.h.

{
    auto qualified_name = declaration.getQualifiedNameAsString();
    util::replace_all(qualified_name, "(anonymous namespace)", "");
    util::replace_all(qualified_name, "::::", "::");
 
    if constexpr (std::is_base_of_v<clang::TagDecl, T>) {
        auto base_name = get_tag_name(declaration);
        model::namespace_ ns{qualified_name};
        ns.pop_back();
        ns = ns | base_name;
 
        return ns.to_string();
    }
 
    return qualified_name;
}

get_raw_comment()

clang::RawComment * clanguml::common::get_raw_comment	(	const clang::SourceManager &	sm,
		const clang::ASTContext &	context,
		const clang::SourceRange &	source_range
	)

Definition at line 1014 of file clang_utils.cc.

{
    auto expr_begin = sm.getExpansionLoc(source_range.getBegin());
    const auto expr_begin_line = sm.getExpansionLineNumber(expr_begin);
 
    auto file_id = sm.getFileID(expr_begin);
 
    const auto has_comments = !context.Comments.empty();
    const auto *comments = context.Comments.getCommentsInFile(file_id);
 
    if (has_comments && comments != nullptr) {
        for (const auto [offset, raw_comment] :
            *context.Comments.getCommentsInFile(sm.getFileID(expr_begin))) {
            const auto comment_end_line = sm.getExpansionLineNumber(
                raw_comment->getSourceRange().getEnd());
 
            if (expr_begin_line == comment_end_line ||
                expr_begin_line == comment_end_line + 1)
                return raw_comment;
        }
    }
 
    return {};
}

get_source_text()

std::string clanguml::common::get_source_text	(	clang::SourceRange	range,
		const clang::SourceManager &	sm
	)

Get printable range of text of specific source range.

Parameters

range	Source range
sm	Source manager reference

Returns

Printable source text

Definition at line 386 of file clang_utils.cc.

{
    const clang::LangOptions lo;
 
    auto start_loc = sm.getSpellingLoc(range.getBegin());
    auto last_token_loc = sm.getSpellingLoc(range.getEnd());
    auto end_loc = clang::Lexer::getLocForEndOfToken(last_token_loc, 0, sm, lo);
    auto printable_range = clang::SourceRange{start_loc, end_loc};
    return get_source_text_raw(printable_range, sm);
}

get_source_text_raw()

std::string clanguml::common::get_source_text_raw	(	clang::SourceRange	range,
		const clang::SourceManager &	sm
	)

Get raw text of specific source range.

Parameters

range	Source range
sm	Source manager reference

Returns

Raw source text

Definition at line 378 of file clang_utils.cc.

{
    return clang::Lexer::getSourceText(
        clang::CharSourceRange::getCharRange(range), sm, clang::LangOptions())
        .str();
}

get_tag_name()

std::string clanguml::common::get_tag_name

(

const clang::TagDecl &

declaration

)

Generate full qualified name for clang::TagDecl instance.

Parameters

declaration

Input declaration

Returns

String representation including any templates, parameters and attribtues

Definition at line 105 of file clang_utils.cc.

{
    auto base_name = declaration.getNameAsString();
 
    if (base_name.empty()) {
        base_name =
            fmt::format("(anonymous_{})", std::to_string(declaration.getID()));
    }
 
    if ((declaration.getParent() != nullptr) &&
        declaration.getParent()->isRecord()) {
        // If the record is nested within another record (e.g. class or struct)
        // we have to maintain a containment namespace in order to ensure
        // unique names within the diagram
        std::deque<std::string> record_parent_names;
        record_parent_names.push_front(base_name);
 
        const auto *cls_parent{declaration.getParent()};
        while (cls_parent->isRecord()) {
            if (const auto *record_decl =
                    clang::dyn_cast<clang::RecordDecl>(cls_parent);
                record_decl != nullptr) {
                record_parent_names.push_front(record_decl->getNameAsString());
            }
            cls_parent = cls_parent->getParent();
        }
        return fmt::format("{}", fmt::join(record_parent_names, "##"));
    }
 
    return base_name;
}

get_tag_namespace()

model::namespace_ clanguml::common::get_tag_namespace

(

const clang::TagDecl &

declaration

)

Get namespace of a specific clang::TagDecl

Parameters

declaration

Reference to clang::TagDecl

Returns

Namespace instance

Definition at line 67 of file clang_utils.cc.

{
    model::namespace_ ns;
 
    const auto *parent{declaration.getParent()};
 
    // First walk up to the nearest namespace, e.g. from nested class or enum
    while ((parent != nullptr) && !parent->isNamespace()) {
        parent = parent->getParent();
    }
 
    // Now build up the namespace
    std::deque<std::string> namespace_tokens;
    while ((parent != nullptr) && parent->isNamespace()) {
        if (const auto *ns_decl = clang::dyn_cast<clang::NamespaceDecl>(parent);
            ns_decl != nullptr) {
            if (!ns_decl->isInline() && !ns_decl->isAnonymousNamespace())
                namespace_tokens.push_front(ns_decl->getNameAsString());
        }
 
        parent = parent->getParent();
    }
 
    for (const auto &ns_token : namespace_tokens) {
        ns |= ns_token;
    }
 
    return ns;
}

get_template_namespace()

model::namespace_ clanguml::common::get_template_namespace

(

const clang::TemplateDecl &

declaration

)

Get namespace of a specific clang::TemplateDecl

Parameters

declaration

Reference to clang::TemplateDecl

Returns

Namespace instance

Definition at line 97 of file clang_utils.cc.

{
    model::namespace_ ns{declaration.getQualifiedNameAsString()};
    ns.pop_back();
 
    return ns;
}

get_typedef_enum_decl()

const clang::EnumDecl * clanguml::common::get_typedef_enum_decl

(

const clang::TypedefDecl *

decl

)

Get pointer to enum decl in typedef decl

Parameters

decl	typedef decl

Returns

Pointer to enum decl inside typedef

Definition at line 1151 of file clang_utils.cc.

{
    if (decl == nullptr)
        return nullptr;
 
    const clang::Type *unqualified_type = get_unqualified_type(decl);
 
    if (unqualified_type->getTypeClass() == clang::Type::Elaborated) {
        const auto *tag_decl =
            clang::cast<clang::ElaboratedType>(unqualified_type)
                ->getNamedType()
                ->getAsTagDecl();
 
        if (tag_decl == nullptr)
            return nullptr;
 
        const auto *enum_decl = clang::dyn_cast<clang::EnumDecl>(tag_decl);
        if (enum_decl != nullptr && enum_decl->getIdentifier() == nullptr)
            return enum_decl;
    }
 
    return nullptr;
}

get_unqualified_type()

const clang::Type * clanguml::common::get_unqualified_type

(

const clang::TypedefDecl *

decl

)

Get the unqualified type of typedef decl

Parameters

decl	typedef decl

Returns

Pointer to underlying type or nullptr

Definition at line 1141 of file clang_utils.cc.

{
    const auto *type_source_info = decl->getTypeSourceInfo();
 
    if (type_source_info == nullptr)
        return nullptr;
 
    return type_source_info->getType().split().Ty;
}

has_attr()

bool clanguml::common::has_attr	(	const clang::FunctionDecl *	decl,
		clang::attr::Kind	function_attr
	)

Check if function declaration contains specified attributed

Parameters

decl	Function declaration
function_attr	Clang function attribute

Returns

True, if decl contains specified function attribute

Definition at line 1063 of file clang_utils.cc.

{
    return std::any_of(decl->attrs().begin(), decl->attrs().end(),
        [function_attr](
            auto &&attr) { return attr->getKind() == function_attr; });
}

if_dyn_cast()

template<typename T , typename P , typename F >

void clanguml::common::if_dyn_cast	(	P	pointer,
		F &&	func
	)

Definition at line 241 of file clang_utils.h.

{
    if (pointer == nullptr)
        return;
 
    if (const auto *dyn_cast_value = clang::dyn_cast<T>(pointer);
        dyn_cast_value) {
        std::forward<F>(func)(dyn_cast_value);
    }
}

is_bracket()

bool clanguml::common::is_bracket

(

const std::string &

b

)

Definition at line 657 of file clang_utils.cc.

{
    return b == "(" || b == ")" || b == "[" || b == "]";
}

is_coroutine()

bool clanguml::common::is_coroutine

(

const clang::FunctionDecl &

decl

)

Check if function or method declaration is a C++20 coroutine.

Parameters

decl	Function declaration

Returns

True, if the function is a C++20 coroutine.

Definition at line 1040 of file clang_utils.cc.

{
    const auto *body = decl.getBody();
    return clang::isa_and_nonnull<clang::CoroutineBodyStmt>(body);
}

is_identifier()

bool clanguml::common::is_identifier

(

const std::string &

t

)

Definition at line 667 of file clang_utils.cc.

{
    return std::all_of(t.begin(), t.end(),
        [](const char c) { return is_identifier_character(c); });
}

is_identifier_character()

bool clanguml::common::is_identifier_character

(

char

c

)

Definition at line 662 of file clang_utils.cc.

{
    return std::isalnum(c) != 0 || c == '_';
}

is_keyword()

bool clanguml::common::is_keyword

(

const std::string &

t

)

Definition at line 673 of file clang_utils.cc.

{
    static std::vector<std::string> keywords{"alignas", "alignof", "asm",
        "auto", "bool", "break", "case", "catch", "char", "char16_t",
        "char32_t", "class", "concept", "const", "constexpr", "const_cast",
        "continue", "decltype", "default", "delete", "do", "double",
        "dynamic_cast", "else", "enum", "explicit", "export", "extern", "false",
        "float", "for", "friend", "goto", "if", "inline", "int", "long",
        "mutable", "namespace", "new", "noexcept", "nullptr", "operator",
        "private", "protected", "public", "register", "reinterpret_cast",
        "return", "requires", "short", "signed", "sizeof", "static",
        "static_assert", "static_cast", "struct", "switch", "template", "this",
        "thread_local", "throw", "true", "try", "typedef", "typeid", "typename",
        "union", "unsigned", "using", "virtual", "void", "volatile", "wchar_t",
        "while"};
 
    return util::contains(keywords, t);
}

is_lambda_call()

bool clanguml::common::is_lambda_call

(

const clang::Expr *

callExpr

)

Check if clang::Expr is a call on lambda operator()

Parameters

callExpr

Returns

True, if the expression points to lambda invocation

Definition at line 1175 of file clang_utils.cc.

{
    const auto *call_expr = clang::dyn_cast<clang::CallExpr>(expr);
 
    if (call_expr == nullptr)
        return false;
 
    if (clang::dyn_cast_or_null<clang::LambdaExpr>(call_expr->getCallee()) !=
        nullptr) {
        return true;
    }
 
    const auto *function_callee = call_expr->getDirectCallee();
    if (function_callee != nullptr) {
 
        const auto *method_decl =
            clang::dyn_cast<clang::CXXMethodDecl>(function_callee);
        if (method_decl == nullptr)
            return false;
 
        if (method_decl->getParent()->isLambda() &&
            method_decl->getOverloadedOperator() == clang::OO_Call) {
            return true;
        }
    }
 
    return false;
}

is_lambda_method()

bool clanguml::common::is_lambda_method

(

const clang::FunctionDecl *

decl

)

Definition at line 1204 of file clang_utils.cc.

{
    if (decl == nullptr)
        return false;
 
    if (const auto *method = clang::dyn_cast<clang::CXXMethodDecl>(decl);
        method != nullptr) {
        if (method->getParent() != nullptr && method->getParent()->isLambda())
            return true;
    }
 
    return false;
}

is_qualified_identifier()

bool clanguml::common::is_qualified_identifier

(

const std::string &

t

)

Definition at line 692 of file clang_utils.cc.

{
    return std::isalpha(t.at(0)) != 0 &&
        std::all_of(t.begin(), t.end(), [](const char c) {
            return is_identifier_character(c) || c == ':';
        });
}

is_qualifier()

bool clanguml::common::is_qualifier

(

const std::string &

q

)

Definition at line 652 of file clang_utils.cc.

{
    return q == "&" || q == "&&" || q == "const&";
}

is_struct()

bool clanguml::common::is_struct

(

const clang::NamedDecl *

decl

)

Check if named declaration is a C++ struct.

Parameters

decl	Declaration to check

Returns

True, if declaration represents a struct.

Definition at line 1046 of file clang_utils.cc.

{
    if (decl == nullptr)
        return false;
 
    if (const auto *record = clang::dyn_cast<clang::CXXRecordDecl>(decl);
        record) {
        return record->isStruct();
    }
 
    if (const auto *tag = clang::dyn_cast<clang::TagDecl>(decl); tag) {
        return tag->isStruct();
    }
 
    return false;
}

is_subexpr_of()

bool clanguml::common::is_subexpr_of	(	const clang::Stmt *	parent_stmt,
		const clang::Stmt *	sub_stmt
	)

Check if an expression is contained in another expression.

This method returns true if sub_stmt is equal to or is contained in the AST subtree of parent_stmt

Parameters

parent_stmt	Parent statement
sub_stmt	Sub statement

Returns

Definition at line 452 of file clang_utils.cc.

{
    if (parent_stmt == nullptr || sub_stmt == nullptr)
        return false;
 
    if (parent_stmt == sub_stmt)
        return true;
 
    return std::any_of(parent_stmt->child_begin(), parent_stmt->child_end(),
        [sub_stmt](const auto *e) { return is_subexpr_of(e, sub_stmt); });
}

is_type_parameter()

bool clanguml::common::is_type_parameter

(

const std::string &

t

)

Definition at line 647 of file clang_utils.cc.

{
    return t.find("type-parameter-") == 0;
}

is_type_token()

bool clanguml::common::is_type_token

(

const std::string &

t

)

Definition at line 700 of file clang_utils.cc.

{
    return is_type_parameter(t) ||
        (is_identifier(t) && !is_qualifier(t) && !is_bracket(t));
}

operator!=() [1/2]

bool clanguml::common::operator!=	(	const eid_t &	lhs,
		const eid_t &	rhs
	)

Definition at line 66 of file types.cc.

{ return !(lhs == rhs); }

operator!=() [2/2]

bool clanguml::common::operator!=	(	const eid_t &	lhs,
		const uint64_t &	v
	)

Definition at line 59 of file types.cc.

{
    assert(v != 0);
 
    return lhs.value_ != v;
}

operator<()

bool clanguml::common::operator<	(	const eid_t &	lhs,
		const eid_t &	rhs
	)

Definition at line 68 of file types.cc.

{
    if (lhs.is_global_ != rhs.is_global_) {
        return lhs.value_ < rhs.value_ + 1;
    }
 
    return lhs.value_ < rhs.value_; // Compare values if is_global_ are the same
}

operator<<()

YAML::Emitter & clanguml::common::operator<<	(	YAML::Emitter &	out,
		const string_or_regex &	m
	)

Definition at line 23 of file yaml_emitters.cc.

{
    if (std::holds_alternative<std::string>(m.value())) {
        out << std::get<std::string>(m.value());
    }
    else {
        out << YAML::BeginMap;
        out << YAML::Key << "r" << YAML::Value
            << std::get<regex>(m.value()).pattern;
        out << YAML::EndMap;
    }
 
    return out;
}

operator==() [1/2]

bool clanguml::common::operator==	(	const eid_t &	lhs,
		const eid_t &	rhs
	)

Definition at line 52 of file types.cc.

{
    return (lhs.is_global_ == rhs.is_global_) && (lhs.value_ == rhs.value_);
}

operator==() [2/2]

bool clanguml::common::operator==	(	const eid_t &	lhs,
		const uint64_t &	v
	)

Definition at line 57 of file types.cc.

{ return lhs.value_ == v; }

parse_source_location()

bool clanguml::common::parse_source_location	(	const std::string &	location_str,
		std::string &	file,
		unsigned &	line,
		unsigned &	column
	)

Definition at line 965 of file clang_utils.cc.

{
    auto tokens = util::split(location_str, ":");
 
    if (tokens.size() < 3)
        return false;
 
    if (tokens.size() == 4) {
        // Handle Windows paths
        decltype(tokens) tmp_tokens{};
        tmp_tokens.emplace_back(
            fmt::format("{}:{}", tokens.at(0), tokens.at(1)));
        tmp_tokens.emplace_back(tokens.at(2));
        tmp_tokens.emplace_back(tokens.at(3));
 
        tokens = std::move(tmp_tokens);
    }
 
    file = tokens.at(0);
    try {
        line = std::stoi(tokens.at(1));
    }
    catch (std::invalid_argument &e) {
        return false;
    }
 
    try {
        column = std::stoi(tokens.at(2));
    }
    catch (std::invalid_argument &e) {
        column = 0;
    }
 
    return true;
}

parse_unexposed_template_params()

std::vector< common::model::template_parameter > clanguml::common::parse_unexposed_template_params	(	const std::string &	params,
		const std::function< std::string(const std::string &)> &	ns_resolve,
		int	depth = 0
	)

Parse unexposed (available as string) template params.

Parameters

params	String parameters as provided by Clang
ns_resolve	Namespace resolver function
depth	Current depth in the template specification

Returns

Parsed template parameter

Definition at line 555 of file clang_utils.cc.

{
    using common::model::template_parameter;
 
    std::vector<template_parameter> res;
 
    auto it = params.begin();
    while (std::isspace(*it) != 0)
        ++it;
 
    std::string type{};
    std::vector<template_parameter> nested_params;
    bool complete_class_template_argument{false};
 
    while (it != params.end()) {
        if (*it == '<') {
            int nested_level{0};
            auto bracket_match_begin = it + 1;
            auto bracket_match_end = bracket_match_begin;
            while (bracket_match_end != params.end()) {
                if (*bracket_match_end == '<') {
                    nested_level++;
                }
                else if (*bracket_match_end == '>') {
                    if (nested_level > 0)
                        nested_level--;
                    else
                        break;
                }
                else {
                }
                bracket_match_end++;
            }
 
            std::string nested_params_str(
                bracket_match_begin, bracket_match_end);
 
            nested_params = parse_unexposed_template_params(
                nested_params_str, ns_resolve, depth + 1);
 
            if (nested_params.empty()) {
                // We couldn't extract any nested template parameters from
                // `nested_params_str` so just add it as type of template
                // argument as is
                nested_params.emplace_back(
                    template_parameter::make_unexposed_argument(
                        nested_params_str));
            }
 
            it = bracket_match_end - 1;
        }
        else if (*it == '>') {
            complete_class_template_argument = true;
            if (depth == 0) {
                break;
            }
        }
        else if (*it == ',') {
            complete_class_template_argument = true;
        }
        else {
            type += *it;
        }
        if (complete_class_template_argument) {
            auto t = template_parameter::make_unexposed_argument(
                ns_resolve(clanguml::util::trim_typename(type)));
            type = "";
            for (auto &&param : nested_params)
                t.add_template_param(std::move(param));
 
            res.emplace_back(std::move(t));
            complete_class_template_argument = false;
        }
        it++;
    }
 
    if (!type.empty()) {
        auto t = template_parameter::make_unexposed_argument(
            ns_resolve(clanguml::util::trim_typename(type)));
        type = "";
        for (auto &&param : nested_params)
            t.add_template_param(std::move(param));
 
        res.emplace_back(std::move(t));
    }
 
    return res;
}

set_source_location()

void clanguml::common::set_source_location	(	clang::SourceManager &	source_manager,
		const clang::SourceLocation &	location,
		clanguml::common::model::source_location &	element,
		std::filesystem::path	tu_path,
		std::filesystem::path	relative_to_path_
	)

Definition at line 1081 of file clang_utils.cc.

{
    namespace fs = std::filesystem;
 
    std::string file;
    unsigned line{};
    unsigned column{};
 
    if (location.isValid()) {
        file =
            source_manager.getFilename(source_manager.getSpellingLoc(location))
                .str();
        line = source_manager.getSpellingLineNumber(location);
        column = source_manager.getSpellingColumnNumber(location);
 
        if (file.empty()) {
            // Why do I have to do this?
            parse_source_location(
                location.printToString(source_manager), file, line, column);
        }
    }
    else {
        auto success = parse_source_location(
            location.printToString(source_manager), file, line, column);
        if (!success) {
            LOG_DBG("Failed to extract source location for element from {}",
                location.printToString(source_manager));
            return;
        }
    }
 
    // ensure the path is absolute
    fs::path file_path{file};
    if (!file_path.is_absolute()) {
        file_path = fs::absolute(file_path);
    }
 
    file_path = weakly_canonical(file_path);
 
    file = file_path.string();
 
    element.set_file(file);
 
    if (util::is_relative_to(file_path, relative_to_path_)) {
        element.set_file_relative(util::path_to_url(
            fs::path{element.file()}.lexically_relative(relative_to_path_)));
    }
    else {
        element.set_file_relative("");
    }
 
    element.set_translation_unit(tu_path.string());
    element.set_line(line);
    element.set_column(column);
    element.set_location_id(location.getHashValue());
}

split_ns()

std::pair< common::model::namespace_, std::string > clanguml::common::split_ns

(

const std::string &

full_name

)

Split qualified name to namespace and name.

Parameters

full_name

Fully qualified element name

Returns

(namespace, name)

Definition at line 542 of file clang_utils.cc.

{
    assert(!full_name.empty());
 
    auto name_before_template = ::clanguml::util::split(full_name, "<")[0];
    auto ns = common::model::namespace_{
        ::clanguml::util::split(name_before_template, "::")};
    auto name = ns.name();
    ns.pop_back();
    return {ns, name};
}

to_id()

template<>

eid_t clanguml::common::to_id

(

const clang::TemplateArgument &

template_argument

)

Definition at line 525 of file clang_utils.cc.

{
    if (template_argument.getKind() == clang::TemplateArgument::Type) {
        if (const auto *enum_type =
                template_argument.getAsType()->getAs<clang::EnumType>();
            enum_type != nullptr)
            return to_id(*enum_type->getAsTagDecl());
 
        if (const auto *record_type =
                template_argument.getAsType()->getAs<clang::RecordType>();
            record_type != nullptr)
            return to_id(*record_type->getAsRecordDecl());
    }
 
    throw std::runtime_error("Cannot generate id for template argument");
}

to_string() [1/16]

std::string clanguml::common::to_string

(

const bool

v

)

Definition at line 86 of file types.cc.

{ return v ? "true" : "false"; }

to_string() [2/16]

std::string clanguml::common::to_string	(	const clang::ArrayType &	array_type,
		const clang::ASTContext &	ctx,
		bool	try_canonical,
		std::vector< std::string > &	dimensions
	)

Definition at line 137 of file clang_utils.cc.

{
    auto maybe_size = get_array_size(array_type);
    std::string array_size =
        maybe_size.has_value() ? std::to_string(maybe_size.value()) : "";
    dimensions.emplace_back(std::move(array_size));
 
    const auto underlying_type = array_type.getElementType();
 
    if (underlying_type->isArrayType())
        return to_string(*underlying_type->getAsArrayTypeUnsafe(), ctx,
            try_canonical, dimensions);
 
    std::string dimensions_str;
    for (const auto &d : dimensions) {
        dimensions_str += fmt::format("[{}]", d);
    }
    return fmt::format(
        "{}{}", to_string(underlying_type, ctx, try_canonical), dimensions_str);
}

to_string() [3/16]

std::string clanguml::common::to_string

(

const clang::Expr *

expr

)

Definition at line 312 of file clang_utils.cc.

{
    const clang::LangOptions lang_options;
    std::string result;
    llvm::raw_string_ostream ostream(result);
    expr->printPretty(ostream, nullptr, clang::PrintingPolicy(lang_options));
 
    return result;
}

to_string() [4/16]

std::string clanguml::common::to_string

(

const clang::FunctionTemplateDecl *

decl

)

Definition at line 337 of file clang_utils.cc.

{
    std::vector<std::string> template_parameters;
    // Handle template function
    for (const auto *parameter : *decl->getTemplateParameters()) {
        if (clang::dyn_cast_or_null<clang::TemplateTypeParmDecl>(parameter) !=
            nullptr) {
            const auto *template_type_parameter =
                clang::dyn_cast_or_null<clang::TemplateTypeParmDecl>(parameter);
 
            std::string template_parameter{
                template_type_parameter->getNameAsString()};
 
            if (template_type_parameter->isParameterPack())
                template_parameter += "...";
 
            template_parameters.emplace_back(std::move(template_parameter));
        }
        else {
            // TODO
        }
    }
    return fmt::format("{}<{}>({})", decl->getQualifiedNameAsString(),
        fmt::join(template_parameters, ","), "");
}

to_string() [5/16]

std::string clanguml::common::to_string	(	const clang::QualType &	type,
		const clang::ASTContext &	ctx,
		bool	try_canonical
	)

Definition at line 181 of file clang_utils.cc.

{
    if (type->isArrayType()) {
        std::vector<std::string> dimensions;
        return to_string(
            *type->getAsArrayTypeUnsafe(), ctx, try_canonical, dimensions);
    }
 
    clang::PrintingPolicy print_policy(ctx.getLangOpts());
    print_policy.SuppressScope = 0;
#if LLVM_VERSION_MAJOR < 21
    print_policy.PrintCanonicalTypes = 0;
#else
    print_policy.PrintAsCanonical = 0;
#endif
 
    std::string result;
 
    result = type.getAsString(print_policy);
 
    if (try_canonical && result.find('<') != std::string::npos) {
        auto canonical_type_name =
            type.getCanonicalType().getAsString(print_policy);
 
        auto result_qualified_template_name =
            result.substr(0, result.find('<'));
        auto result_template_arguments = result.substr(result.find('<'));
 
        auto canonical_qualified_template_name =
            canonical_type_name.substr(0, canonical_type_name.find('<'));
 
        // Choose the longer name (why do I have to do this?)
        if (result_qualified_template_name.size() <
            canonical_qualified_template_name.size()) {
 
            result =
                canonical_qualified_template_name + result_template_arguments;
        }
    }
 
    // If for any reason clang reports the type as empty string, make sure
    // it has some default name
    if (result.empty())
        result = "(anonymous)";
    else if (util::contains(result, "unnamed struct") ||
        util::contains(result, "unnamed union")) {
        const auto *declarationTag = type->getAsTagDecl();
        if (declarationTag == nullptr) {
            result = "(unnamed undeclared)";
        }
        else {
            result = common::get_tag_name(*declarationTag);
        }
    }
    else if (util::contains(result, "anonymous struct") ||
        util::contains(result, "anonymous union")) {
        result = common::get_tag_name(*type->getAsTagDecl());
    }
 
    // Remove trailing spaces after commas in template arguments
    clanguml::util::replace_all(result, ", ", ",");
    clanguml::util::replace_all(result, "> >", ">>");
 
    // Try to get rid of 'type-parameter-X-Y' ugliness
    if (result.find("type-parameter-") != std::string::npos) {
        util::if_not_null(
            common::dereference(type)->getAs<clang::TypedefType>(),
            [&result, &type](auto *p) {
                auto [unqualified_type, context] =
                    common::consume_type_context(type);
                result = p->getDecl()->getNameAsString();
                if (!context.empty()) {
                    std::vector<std::string> deduced_contexts;
 
                    for (const auto &c : context) {
                        deduced_contexts.push_back(c.to_string());
                    }
 
                    result = fmt::format(
                        "{} {}", result, fmt::join(deduced_contexts, " "));
                }
            });
    }
 
    return result;
}

to_string() [6/16]

std::string clanguml::common::to_string	(	const clang::RecordType &	type,
		const clang::ASTContext &	ctx,
		bool	try_canonical
	)

Definition at line 269 of file clang_utils.cc.

{
    return to_string(type.desugar(), ctx, try_canonical);
}

to_string() [7/16]

std::string clanguml::common::to_string

(

const clang::Stmt *

stmt

)

Definition at line 327 of file clang_utils.cc.

{
    const clang::LangOptions lang_options;
    std::string result;
    llvm::raw_string_ostream ostream(result);
    stmt->printPretty(ostream, nullptr, clang::PrintingPolicy(lang_options));
 
    return result;
}

to_string() [8/16]

std::string clanguml::common::to_string	(	const clang::TemplateArgument &	arg,
		const clang::ASTContext *	ctx
	)

Definition at line 275 of file clang_utils.cc.

{
    switch (arg.getKind()) {
    case clang::TemplateArgument::Expression:
        return to_string(arg.getAsExpr());
    case clang::TemplateArgument::Type:
        return to_string(arg.getAsType(), *ctx, false);
    case clang::TemplateArgument::Null:
        return "";
    case clang::TemplateArgument::NullPtr:
        return "nullptr";
    case clang::TemplateArgument::Integral:
        return std::to_string(arg.getAsIntegral().getExtValue());
    case clang::TemplateArgument::Template:
        return to_string(arg.getAsTemplate());
    case clang::TemplateArgument::TemplateExpansion:
        return to_string(arg.getAsTemplateOrTemplatePattern());
    default:
        return "";
    }
}

to_string() [9/16]

std::string clanguml::common::to_string	(	const clang::TemplateArgumentLoc &	argLoc,
		const clang::ASTContext &	context
	)

Definition at line 160 of file clang_utils.cc.

{
    std::string result;
    llvm::raw_string_ostream stream(result);
 
    clang::PrintingPolicy policy(context.getLangOpts());
 
    const clang::TemplateArgument &arg = argLoc.getArgument();
 
#if LLVM_VERSION_MAJOR > 18
    arg.print(policy, stream, false);
#else
    arg.dump(stream);
#endif
 
    stream.flush();
 
    return result;
}

to_string() [10/16]

std::string clanguml::common::to_string

(

const clang::TemplateName &

templ

)

Definition at line 298 of file clang_utils.cc.

{
    if (templ.getAsTemplateDecl() != nullptr) {
        return templ.getAsTemplateDecl()->getQualifiedNameAsString();
    }
 
    std::string result;
    const clang::LangOptions lang_options;
    llvm::raw_string_ostream ostream(result);
    templ.print(ostream, clang::PrintingPolicy(lang_options));
 
    return result;
}

to_string() [11/16]

std::string clanguml::common::to_string

(

const clang::TypeConstraint *

tc

)

Definition at line 363 of file clang_utils.cc.

{
    if (tc == nullptr)
        return {};
 
    const clang::PrintingPolicy print_policy(
        tc->getNamedConcept()->getASTContext().getLangOpts());
 
    std::string ostream_buf;
    llvm::raw_string_ostream ostream{ostream_buf};
    tc->print(ostream, print_policy);
 
    return ostream.str();
}

to_string() [12/16]

std::string clanguml::common::to_string

(

const clang::ValueDecl *

val

)

Definition at line 322 of file clang_utils.cc.

{
    return val->getQualifiedNameAsString();
}

to_string() [13/16]

std::string clanguml::common::to_string

(

const generator_type_t

type

)

Definition at line 94 of file types.cc.

{
    switch (type) {
    case generator_type_t::plantuml:
        return "plantuml";
    case generator_type_t::mermaid:
        return "mermaid";
    case generator_type_t::json:
        return "json";
    case generator_type_t::graphml:
        return "graphml";
    default:
        return "<unknown>";
    }
}

to_string() [14/16]

std::string clanguml::common::to_string

(

const std::filesystem::path &

p

)

Definition at line 92 of file types.cc.

{ return p.string(); }

to_string() [15/16]

std::string clanguml::common::to_string

(

const std::string &

s

)

Definition at line 88 of file types.cc.

{ return s; }

to_string() [16/16]

std::string clanguml::common::to_string

(

const string_or_regex &

sr

)

Definition at line 90 of file types.cc.

{ return sr.to_string(); }

tokenize_unexposed_template_parameter()

std::vector< std::string > clanguml::common::tokenize_unexposed_template_parameter

(

const std::string &

t

)

Definition at line 882 of file clang_utils.cc.

{
    std::vector<std::string> result;
 
    auto spaced_out = util::split(t, " ");
 
    for (const auto &word : spaced_out) {
        if (is_qualified_identifier(word)) {
            if (word != "class" && word != "templated" && word != "struct")
                result.emplace_back(word);
            continue;
        }
 
        std::string tok;
 
        for (const char c : word) {
            if (c == '(' || c == ')' || c == '[' || c == ']' || c == '<' ||
                c == '>') {
                if (!tok.empty())
                    result.emplace_back(tok);
                result.emplace_back(std::string{c});
                tok.clear();
            }
            else if (c == ':') {
                if (!tok.empty() && tok != ":") {
                    result.emplace_back(tok);
                    tok = ":";
                }
                else if (tok == ":") {
                    result.emplace_back("::");
                    tok = "";
                }
                else {
                    tok += ':';
                }
            }
            else if (c == ',') {
                if (!tok.empty()) {
                    result.emplace_back(tok);
                }
                result.emplace_back(",");
                tok.clear();
            }
            else if (c == '*') {
                if (!tok.empty()) {
                    result.emplace_back(tok);
                }
                result.emplace_back("*");
                tok.clear();
            }
            else if (c == '.') {
                // This can only be the case if we have a variadic template,
                // right?
                if (tok == "..") {
                    result.emplace_back("...");
                    tok.clear();
                }
                else if (tok == ".") {
                    tok = "..";
                }
                else if (!tok.empty()) {
                    result.emplace_back(tok);
                    tok = ".";
                }
            }
            else {
                tok += c;
            }
        }
 
        tok = util::trim(tok);
 
        if (!tok.empty()) {
            if (tok != "class" && tok != "typename" && word != "struct")
                result.emplace_back(tok);
            tok.clear();
        }
    }
 
    return result;
}