matthias/clang-uml
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge pull request #148 from bkryza/add-packages-from-directory-structure

Browse Source 
Add packages from directory structure
This commit is contained in:
Bartek Kryza
2023-05-28 22:58:45 +02:00
committed by GitHub
parent 044c9ced19 f273f6b2f7
commit 77f3325d6a
291 changed files with 7038 additions and 4416 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
src/class_diagram/generators/json/class_diagram_generator.cc
View File

@@ -168,7 +168,11 @@ void generator::generate(const package &p, nlohmann::json &parent) const
if (!uns.starts_with({p.full_name(false)})) {
LOG_DBG("Generating package {}", p.name());
package_object["type"] = "namespace";
if (m_config.package_type() == config::package_type_t::kDirectory)
package_object["type"] = "directory";
else
package_object["type"] = "namespace";
package_object["name"] = p.name();
package_object["display_name"] = p.full_name(false);
}

14
src/class_diagram/generators/plantuml/class_diagram_generator.cc
View File

@@ -721,9 +721,14 @@ void generator::generate_relationships(
{
for (const auto &subpackage : p) {
if (dynamic_cast<package *>(subpackage.get()) != nullptr) {
// TODO: add option - generate_empty_packages
// TODO: add option - generate_empty_packages, currently
// packages which do not contain anything but other packages
// are skipped
const auto &sp = dynamic_cast<package &>(*subpackage);
if (!sp.is_empty())
if (!sp.is_empty() &&
!sp.all_of([this](const common::model::element &e) {
return !m_model.should_include(e);
}))
generate_relationships(sp, ostr);
}
else if (dynamic_cast<class_ *>(subpackage.get()) != nullptr) {
@@ -774,7 +779,10 @@ void generator::generate_top_level_elements(std::ostream &ostr) const
{
for (const auto &p : m_model) {
if (auto *pkg = dynamic_cast<package *>(p.get()); pkg) {
if (!pkg->is_empty())
if (!pkg->is_empty() &&
!pkg->all_of([this](const common::model::element &e) {
return !m_model.should_include(e);
}))
generate(*pkg, ostr);
}
else if (auto *cls = dynamic_cast<class_ *>(p.get()); cls) {

260
src/class_diagram/model/diagram.cc
View File

@@ -21,20 +21,21 @@
#include "util/error.h"
#include "util/util.h"
#include <cassert>
namespace clanguml::class_diagram::model {
const common::reference_vector<class_> &diagram::classes() const
{
return classes_;
return element_view<class_>::view();
}
const common::reference_vector<enum_> &diagram::enums() const { return enums_; }
const common::reference_vector<enum_> &diagram::enums() const
{
return element_view<enum_>::view();
}
const common::reference_vector<concept_> &diagram::concepts() const
{
return concepts_;
return element_view<concept_>::view();
}
common::model::diagram_t diagram::type() const
@@ -46,17 +47,17 @@ common::optional_ref<clanguml::common::model::diagram_element> diagram::get(
const std::string &full_name) const
{
common::optional_ref<clanguml::common::model::diagram_element> res =
get_class(full_name);
find<class_>(full_name);
if (res.has_value())
return res;
res = get_enum(full_name);
res = find<enum_>(full_name);
if (res.has_value())
return res;
res = get_concept(full_name);
res = find<concept_>(full_name);
return res;
}
@@ -66,114 +67,24 @@ common::optional_ref<clanguml::common::model::diagram_element> diagram::get(
{
common::optional_ref<clanguml::common::model::diagram_element> res;
res = get_class(id);
res = find<class_>(id);
if (res.has_value())
return res;
res = get_enum(id);
res = find<enum_>(id);
if (res.has_value())
return res;
res = get_concept(id);
res = find<concept_>(id);
return res;
}
bool diagram::has_class(const class_ &c) const
{
return std::any_of(classes_.cbegin(), classes_.cend(),
[&c](const auto &cc) { return cc.get() == c; });
}
bool diagram::has_enum(const enum_ &e) const
{
return std::any_of(enums_.cbegin(), enums_.cend(),
[&e](const auto &ee) { return ee.get().full_name() == e.full_name(); });
}
bool diagram::has_concept(const concept_ &c) const
{
return std::any_of(concepts_.cbegin(), concepts_.cend(),
[&c](const auto &cc) { return cc.get() == c; });
}
common::optional_ref<class_> diagram::get_class(const std::string &name) const
{
for (const auto &c : classes_) {
const auto full_name = c.get().full_name(false);
if (full_name == name) {
return {c};
}
}
return {};
}
common::optional_ref<class_> diagram::get_class(
clanguml::common::model::diagram_element::id_t id) const
{
for (const auto &c : classes_) {
if (c.get().id() == id) {
return {c};
}
}
return {};
}
common::optional_ref<enum_> diagram::get_enum(const std::string &name) const
{
for (const auto &e : enums_) {
if (e.get().full_name(false) == name) {
return {e};
}
}
return {};
}
common::optional_ref<enum_> diagram::get_enum(
clanguml::common::model::diagram_element::id_t id) const
{
for (const auto &e : enums_) {
if (e.get().id() == id) {
return {e};
}
}
return {};
}
common::optional_ref<concept_> diagram::get_concept(
const std::string &name) const
{
for (const auto &c : concepts_) {
const auto full_name = c.get().full_name(false);
if (full_name == name) {
return {c};
}
}
return {};
}
common::optional_ref<concept_> diagram::get_concept(
clanguml::common::model::diagram_element::id_t id) const
{
for (const auto &c : concepts_) {
if (c.get().id() == id) {
return {c};
}
}
return {};
}
bool diagram::add_package(std::unique_ptr<common::model::package> &&p)
template <>
bool diagram::add_with_namespace_path<common::model::package>(
std::unique_ptr<common::model::package> &&p)
{
LOG_DBG("Adding namespace package: {}, {}", p->name(), p->full_name(true));
@@ -182,125 +93,16 @@ bool diagram::add_package(std::unique_ptr<common::model::package> &&p)
return add_element(ns, std::move(p));
}
bool diagram::add_class(std::unique_ptr<class_> &&c)
template <>
bool diagram::add_with_filesystem_path<common::model::package>(
const common::model::path & /*parent_path*/,
std::unique_ptr<common::model::package> &&p)
{
const auto base_name = c->name();
const auto full_name = c->full_name(false);
LOG_DBG("Adding filesystem package: {}, {}", p->name(), p->full_name(true));
LOG_DBG("Adding class: {}::{}, {}", c->get_namespace().to_string(),
base_name, full_name);
auto ns = p->get_relative_namespace();
if (util::contains(base_name, "::"))
throw std::runtime_error("Name cannot contain namespace: " + base_name);
if (util::contains(base_name, "*"))
throw std::runtime_error("Name cannot contain *: " + base_name);
const auto ns = c->get_relative_namespace();
auto name = base_name;
auto name_with_ns = c->name_and_ns();
auto name_and_ns = ns | name;
auto &cc = *c;
auto id = cc.id();
try {
if (!has_class(cc)) {
if (add_element(ns, std::move(c)))
classes_.push_back(std::ref(cc));
const auto &el = get_element<class_>(name_and_ns).value();
if ((el.name() != name) || !(el.get_relative_namespace() == ns))
throw std::runtime_error(
"Invalid element stored in the diagram tree");
LOG_DBG("Added class {} ({} - [{}])", base_name, full_name, id);
return true;
}
}
catch (const std::runtime_error &e) {
LOG_WARN(
"Cannot add concept {} with id {} due to: {}", name, id, e.what());
return false;
}
LOG_DBG(
"Class {} ({} - [{}]) already in the model", base_name, full_name, id);
return false;
}
bool diagram::add_enum(std::unique_ptr<enum_> &&e)
{
const auto full_name = e->name();
LOG_DBG("Adding enum: {}", full_name);
assert(!util::contains(e->name(), "::"));
auto e_ref = std::ref(*e);
auto ns = e->get_relative_namespace();
if (!has_enum(*e)) {
if (add_element(ns, std::move(e))) {
enums_.emplace_back(e_ref);
return true;
}
}
LOG_DBG("Enum {} already in the model", full_name);
return false;
}
bool diagram::add_concept(std::unique_ptr<concept_> &&c)
{
const auto base_name = c->name();
const auto full_name = c->full_name(false);
LOG_DBG("Adding concept: {}::{}, {}", c->get_namespace().to_string(),
base_name, full_name);
if (util::contains(base_name, "::"))
throw std::runtime_error("Name cannot contain namespace: " + base_name);
if (util::contains(base_name, "*"))
throw std::runtime_error("Name cannot contain *: " + base_name);
const auto ns = c->get_relative_namespace();
auto name = base_name;
auto name_with_ns = c->name_and_ns();
auto name_and_ns = ns | name;
auto &cc = *c;
auto id = cc.id();
try {
if (!has_concept(cc)) {
if (add_element(ns, std::move(c)))
concepts_.push_back(std::ref(cc));
const auto &el = get_element<concept_>(name_and_ns).value();
if ((el.name() != name) || !(el.get_relative_namespace() == ns))
throw std::runtime_error(
"Invalid element stored in the diagram tree");
LOG_DBG("Added concept {} ({} - [{}])", base_name, full_name, id);
return true;
}
}
catch (const std::runtime_error &e) {
LOG_WARN(
"Cannot add concept {} with id {} due to: {}", name, id, e.what());
return false;
}
LOG_DBG("Concept {} ({} - [{}]) already in the model", base_name, full_name,
id);
return false;
return add_element(ns, std::move(p));
}
void diagram::get_parents(
@@ -309,7 +111,7 @@ void diagram::get_parents(
bool found_new{false};
for (const auto &parent : parents) {
for (const auto &pp : parent.get().parents()) {
auto p = get_class(pp.id());
auto p = find<class_>(pp.id());
if (p.has_value()) {
auto [it, found] = parents.emplace(std::ref(p.value()));
@@ -327,13 +129,19 @@ void diagram::get_parents(
bool diagram::has_element(
clanguml::common::model::diagram_element::id_t id) const
{
const auto has_class = std::any_of(classes_.begin(), classes_.end(),
const auto has_class = std::any_of(classes().begin(), classes().end(),
[id](const auto &c) { return c.get().id() == id; });
if (has_class)
return true;
return std::any_of(enums_.begin(), enums_.end(),
const auto has_concept = std::any_of(classes().begin(), classes().end(),
[id](const auto &c) { return c.get().id() == id; });
if (has_concept)
return true;
return std::any_of(enums().begin(), enums().end(),
[id](const auto &c) { return c.get().id() == id; });
}
@@ -342,18 +150,18 @@ std::string diagram::to_alias(
{
LOG_DBG("Looking for alias for {}", id);
for (const auto &c : classes_) {
for (const auto &c : classes()) {
if (c.get().id() == id) {
return c.get().alias();
}
}
for (const auto &e : enums_) {
for (const auto &e : enums()) {
if (e.get().id() == id)
return e.get().alias();
}
for (const auto &c : concepts_) {
for (const auto &c : concepts()) {
if (c.get().id() == id)
return c.get().alias();
}

212
src/class_diagram/model/diagram.h
View File

@@ -19,6 +19,7 @@
#include "class.h"
#include "common/model/diagram.h"
#include "common/model/element_view.h"
#include "common/model/nested_trait.h"
#include "common/model/package.h"
#include "common/types.h"
@@ -31,10 +32,22 @@
namespace clanguml::class_diagram::model {
class diagram : public clanguml::common::model::diagram,
public clanguml::common::model::nested_trait<
clanguml::common::model::element,
clanguml::common::model::namespace_> {
using common::opt_ref;
using common::model::diagram_element;
using common::model::diagram_t;
using common::model::element_view;
using common::model::path;
using common::model::path_type;
using nested_trait_ns =
clanguml::common::model::nested_trait<clanguml::common::model::element,
clanguml::common::model::namespace_>;
class diagram : public common::model::diagram,
public element_view<class_>,
public element_view<enum_>,
public element_view<concept_>,
public nested_trait_ns {
public:
diagram() = default;
@@ -43,13 +56,11 @@ public:
diagram &operator=(const diagram &) = delete;
diagram &operator=(diagram &&) = default;
common::model::diagram_t type() const override;
diagram_t type() const override;
common::optional_ref<common::model::diagram_element> get(
const std::string &full_name) const override;
opt_ref<diagram_element> get(const std::string &full_name) const override;
common::optional_ref<common::model::diagram_element> get(
clanguml::common::model::diagram_element::id_t id) const override;
opt_ref<diagram_element> get(diagram_element::id_t id) const override;
const common::reference_vector<class_> &classes() const;
@@ -57,54 +68,173 @@ public:
const common::reference_vector<concept_> &concepts() const;
bool has_class(const class_ &c) const;
template <typename ElementT> bool contains(const ElementT &e);
bool has_enum(const enum_ &e) const;
template <typename ElementT>
opt_ref<ElementT> find(const std::string &name) const;
bool has_concept(const concept_ &e) const;
template <typename ElementT>
opt_ref<ElementT> find(diagram_element::id_t id) const;
common::optional_ref<class_> get_class(const std::string &name) const;
template <typename ElementT>
bool add(const path &parent_path, std::unique_ptr<ElementT> &&e)
{
if (parent_path.type() == common::model::path_type::kNamespace) {
return add_with_namespace_path(std::move(e));
}
common::optional_ref<class_> get_class(
clanguml::common::model::diagram_element::id_t id) const;
return add_with_filesystem_path(parent_path, std::move(e));
}
common::optional_ref<enum_> get_enum(const std::string &name) const;
common::optional_ref<enum_> get_enum(
clanguml::common::model::diagram_element::id_t id) const;
common::optional_ref<concept_> get_concept(const std::string &name) const;
common::optional_ref<concept_> get_concept(
clanguml::common::model::diagram_element::id_t id) const;
bool add_class(std::unique_ptr<class_> &&c);
bool add_enum(std::unique_ptr<enum_> &&e);
bool add_concept(std::unique_ptr<concept_> &&e);
bool add_package(std::unique_ptr<common::model::package> &&p);
std::string to_alias(
clanguml::common::model::diagram_element::id_t id) const;
std::string to_alias(diagram_element::id_t id) const;
void get_parents(clanguml::common::reference_set<class_> &parents) const;
friend void print_diagram_tree(const diagram &d, int level);
bool has_element(
clanguml::common::model::diagram_element::id_t id) const override;
bool has_element(diagram_element::id_t id) const override;
inja::json context() const override;
private:
common::reference_vector<class_> classes_;
template <typename ElementT>
bool add_with_namespace_path(std::unique_ptr<ElementT> &&e);
common::reference_vector<enum_> enums_;
common::reference_vector<concept_> concepts_;
template <typename ElementT>
bool add_with_filesystem_path(
const common::model::path &parent_path, std::unique_ptr<ElementT> &&e);
};
template <typename ElementT> bool diagram::contains(const ElementT &element)
{
return std::any_of(element_view<ElementT>::view().cbegin(),
element_view<ElementT>::view().cend(),
[&element](
const auto &element_opt) { return element_opt.get() == element; });
}
template <typename ElementT>
bool diagram::add_with_namespace_path(std::unique_ptr<ElementT> &&e)
{
const auto base_name = e->name();
const auto full_name = e->full_name(false);
const auto element_type = e->type_name();
LOG_DBG("Adding {}: {}::{}, {}", element_type,
e->get_namespace().to_string(), base_name, full_name);
if (util::contains(base_name, "::"))
throw std::runtime_error("Name cannot contain namespace: " + base_name);
if (util::contains(base_name, "*"))
throw std::runtime_error("Name cannot contain *: " + base_name);
const auto ns = e->get_relative_namespace();
auto name = base_name;
auto name_with_ns = e->name_and_ns();
auto name_and_ns = ns | name;
auto &e_ref = *e;
auto id = e_ref.id();
try {
if (!contains(e_ref)) {
if (add_element(ns, std::move(e)))
element_view<ElementT>::add(std::ref(e_ref));
const auto &el = get_element<ElementT>(name_and_ns).value();
if ((el.name() != name) || !(el.get_relative_namespace() == ns))
throw std::runtime_error(
"Invalid element stored in the diagram tree");
LOG_DBG("Added {} {} ({} - [{}])", element_type, base_name,
full_name, id);
return true;
}
}
catch (const std::runtime_error &e) {
LOG_WARN("Cannot add {} {} with id {} due to: {}", element_type, name,
id, e.what());
return false;
}
LOG_DBG("{} {} ({} - [{}]) already in the model", element_type, base_name,
full_name, id);
return false;
}
template <typename ElementT>
bool diagram::add_with_filesystem_path(
const common::model::path &parent_path, std::unique_ptr<ElementT> &&e)
{
const auto element_type = e->type_name();
// Make sure all parent directories are already packages in the
// model
for (auto it = parent_path.begin(); it != parent_path.end(); it++) {
auto pkg =
std::make_unique<common::model::package>(e->using_namespace());
pkg->set_name(*it);
auto ns = common::model::path(parent_path.begin(), it);
// ns.pop_back();
pkg->set_namespace(ns);
pkg->set_id(common::to_id(pkg->full_name(false)));
add(ns, std::move(pkg));
}
const auto base_name = e->name();
const auto full_name = e->full_name(false);
auto &e_ref = *e;
if (add_element(parent_path, std::move(e))) {
element_view<ElementT>::add(std::ref(e_ref));
return true;
}
return false;
}
template <typename ElementT>
opt_ref<ElementT> diagram::find(const std::string &name) const
{
for (const auto &element : element_view<ElementT>::view()) {
const auto full_name = element.get().full_name(false);
if (full_name == name) {
return {element};
}
}
return {};
}
template <typename ElementT>
opt_ref<ElementT> diagram::find(diagram_element::id_t id) const
{
for (const auto &element : element_view<ElementT>::view()) {
if (element.get().id() == id) {
return {element};
}
}
return {};
}
//
// Template method specialization pre-declarations...
//
template <>
bool diagram::add_with_namespace_path<common::model::package>(
std::unique_ptr<common::model::package> &&p);
template <>
bool diagram::add_with_filesystem_path<common::model::package>(
const common::model::path &parent_path,
std::unique_ptr<common::model::package> &&p);
} // namespace clanguml::class_diagram::model
namespace clanguml::common::model {

71
src/class_diagram/visitor/template_builder.cc
View File

@@ -23,14 +23,13 @@
namespace clanguml::class_diagram::visitor {
template_builder::template_builder(class_diagram::model::diagram &d,
const config::class_diagram &config,
common::visitor::ast_id_mapper &id_mapper,
clang::SourceManager &source_manager)
: diagram_{d}
, config_{config}
, id_mapper_{id_mapper}
, source_manager_{source_manager}
template_builder::template_builder(
clanguml::class_diagram::visitor::translation_unit_visitor &visitor)
: diagram_{visitor.diagram()}
, config_{visitor.config()}
, id_mapper_{visitor.id_mapper()}
, source_manager_{visitor.source_manager()}
, visitor_{visitor}
{
}
@@ -268,6 +267,8 @@ std::unique_ptr<class_> template_builder::build(const clang::NamedDecl *cls,
template_instantiation.set_id(
common::to_id(template_instantiation_ptr->full_name(false)));
visitor_.set_source_location(*template_decl, *template_instantiation_ptr);
return template_instantiation_ptr;
}
@@ -936,9 +937,9 @@ std::optional<template_parameter> template_builder::try_as_decl_type(
std::optional<template_parameter> template_builder::try_as_typedef_type(
std::optional<clanguml::class_diagram::model::class_ *> &parent,
const clang::NamedDecl *cls, const clang::TemplateDecl *template_decl,
clang::QualType &type, class_ &template_instantiation,
size_t argument_index)
const clang::NamedDecl * /*cls*/,
const clang::TemplateDecl * /*template_decl*/, clang::QualType &type,
class_ & /*template_instantiation*/, size_t /*argument_index*/)
{
const auto *typedef_type =
common::dereference(type)->getAs<clang::TypedefType>();
@@ -1045,7 +1046,9 @@ template_builder::try_as_template_specialization_type(
}
if (diagram().should_include(nested_template_instantiation_full_name)) {
diagram().add_class(std::move(nested_template_instantiation));
visitor_.set_source_location(
*template_decl, *nested_template_instantiation);
visitor_.add_class(std::move(nested_template_instantiation));
}
return argument;
@@ -1089,7 +1092,7 @@ std::optional<template_parameter> template_builder::try_as_template_parm_type(
argument.is_variadic(is_variadic);
ensure_lambda_type_is_relative(type_parameter_name);
visitor_.ensure_lambda_type_is_relative(type_parameter_name);
return argument;
}
@@ -1108,7 +1111,7 @@ std::optional<template_parameter> template_builder::try_as_lambda(
auto argument = template_parameter::make_argument("");
type = consume_context(type, argument);
ensure_lambda_type_is_relative(type_name);
visitor_.ensure_lambda_type_is_relative(type_name);
argument.set_type(type_name);
return argument;
@@ -1156,8 +1159,8 @@ std::optional<template_parameter> template_builder::try_as_record_type(
if (parent.has_value())
parent.value()->add_relationship(
{relationship_t::kDependency, tag_argument->id()});
diagram().add_class(std::move(tag_argument));
visitor_.set_source_location(*template_decl, *tag_argument);
visitor_.add_class(std::move(tag_argument));
}
}
}
@@ -1256,40 +1259,4 @@ bool template_builder::add_base_classes(class_ &tinst,
return variadic_params;
}
void template_builder::ensure_lambda_type_is_relative(
std::string &parameter_type) const
{
#ifdef _MSC_VER
auto root_name = fmt::format(
"{}\\", std::filesystem::current_path().root_name().string());
if (root_name.back() == '\\') {
root_name.pop_back();
root_name.push_back('/');
}
#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 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(std::filesystem::relative(
absolute_lambda_path, config().relative_to())
.string());
parameter_type = fmt::format("{}(lambda at {}{}",
parameter_type.substr(0, lambda_begin), relative_lambda_path,
parameter_type.substr(absolute_lambda_path_end));
}
}
} // namespace clanguml::class_diagram::visitor

12
src/class_diagram/visitor/template_builder.h
View File

@@ -34,12 +34,12 @@ using found_relationships_t =
std::vector<std::pair<clanguml::common::model::diagram_element::id_t,
common::model::relationship_t>>;
class translation_unit_visitor;
class template_builder {
public:
template_builder(class_diagram::model::diagram &d,
const config::class_diagram &config,
common::visitor::ast_id_mapper &id_mapper,
clang::SourceManager &source_manager);
template_builder(
clanguml::class_diagram::visitor::translation_unit_visitor &visitor);
class_diagram::model::diagram &diagram();
@@ -181,8 +181,6 @@ public:
clang::SourceManager &source_manager() const;
private:
void ensure_lambda_type_is_relative(std::string &parameter_type) const;
// Reference to the output diagram model
clanguml::class_diagram::model::diagram &diagram_;
@@ -192,6 +190,8 @@ private:
common::visitor::ast_id_mapper &id_mapper_;
clang::SourceManager &source_manager_;
clanguml::class_diagram::visitor::translation_unit_visitor &visitor_;
};
} // namespace clanguml::class_diagram::visitor

144
src/class_diagram/visitor/translation_unit_visitor.cc
View File

@@ -32,7 +32,7 @@ translation_unit_visitor::translation_unit_visitor(clang::SourceManager &sm,
: common::visitor::translation_unit_visitor{sm, config}
, diagram_{diagram}
, config_{config}
, template_builder_{diagram_, config_, id_mapper_, sm}
, template_builder_{*this}
{
}
@@ -40,6 +40,9 @@ bool translation_unit_visitor::VisitNamespaceDecl(clang::NamespaceDecl *ns)
{
assert(ns != nullptr);
if (config().package_type() == config::package_type_t::kDirectory)
return true;
if (ns->isAnonymousNamespace() || ns->isInline())
return true;
@@ -81,7 +84,7 @@ bool translation_unit_visitor::VisitNamespaceDecl(clang::NamespaceDecl *ns)
}
if (!p->skip()) {
diagram().add_package(std::move(p));
diagram().add(package_path, std::move(p));
}
}
@@ -137,8 +140,8 @@ bool translation_unit_visitor::VisitEnumDecl(clang::EnumDecl *enm)
}
}
if (id_opt && diagram_.get_class(*id_opt)) {
auto parent_class = diagram_.get_class(*id_opt);
if (id_opt && diagram().find<class_>(*id_opt)) {
auto parent_class = diagram().find<class_>(*id_opt);
e.set_namespace(ns);
e.set_name(parent_class.value().name() + "##" + enm->getNameAsString());
@@ -167,7 +170,7 @@ bool translation_unit_visitor::VisitEnumDecl(clang::EnumDecl *enm)
}
if (diagram().should_include(qualified_name))
diagram().add_enum(std::move(e_ptr));
add_enum(std::move(e_ptr));
return true;
}
@@ -222,14 +225,14 @@ bool translation_unit_visitor::VisitClassTemplateSpecializationDecl(
{relationship_t::kInstantiation, maybe_id.value()});
}
if (diagram_.should_include(template_specialization)) {
if (diagram().should_include(template_specialization)) {
const auto full_name = template_specialization.full_name(false);
const auto id = template_specialization.id();
LOG_DBG("Adding class template specialization {} with id {}", full_name,
id);
diagram_.add_class(std::move(template_specialization_ptr));
add_class(std::move(template_specialization_ptr));
}
return true;
@@ -262,13 +265,13 @@ bool translation_unit_visitor::VisitTypeAliasTemplateDecl(
if (!template_specialization_ptr)
return true;
if (diagram_.should_include(*template_specialization_ptr)) {
if (diagram().should_include(*template_specialization_ptr)) {
const auto name = template_specialization_ptr->full_name();
const auto id = template_specialization_ptr->id();
LOG_DBG("Adding class {} with id {}", name, id);
diagram_.add_class(std::move(template_specialization_ptr));
add_class(std::move(template_specialization_ptr));
}
return true;
@@ -324,11 +327,11 @@ bool translation_unit_visitor::VisitClassTemplateDecl(
process_class_declaration(*cls->getTemplatedDecl(), *c_ptr);
forward_declarations_.erase(id);
if (diagram_.should_include(*c_ptr)) {
if (diagram().should_include(*c_ptr)) {
const auto name = c_ptr->full_name();
LOG_DBG("Adding class template {} with id {}", name, id);
diagram_.add_class(std::move(c_ptr));
add_class(std::move(c_ptr));
}
return true;
@@ -361,8 +364,8 @@ bool translation_unit_visitor::VisitRecordDecl(clang::RecordDecl *rec)
id_mapper().add(rec->getID(), rec_id);
auto &record_model = diagram().get_class(rec_id).has_value()
? *diagram().get_class(rec_id).get()
auto &record_model = diagram().find<class_>(rec_id).has_value()
? *diagram().find<class_>(rec_id).get()
: *record_ptr;
if (rec->isCompleteDefinition() && !record_model.complete()) {
@@ -377,11 +380,11 @@ bool translation_unit_visitor::VisitRecordDecl(clang::RecordDecl *rec)
}
forward_declarations_.erase(id);
if (diagram_.should_include(record_model)) {
if (diagram().should_include(record_model)) {
LOG_DBG("Adding struct/union {} with id {}",
record_model.full_name(false), record_model.id());
diagram_.add_class(std::move(record_ptr));
add_class(std::move(record_ptr));
}
else {
LOG_DBG("Skipping struct/union {} with id {}", record_model.full_name(),
@@ -433,11 +436,11 @@ bool translation_unit_visitor::TraverseConceptDecl(clang::ConceptDecl *cpt)
*concept_model, cpt->getConstraintExpr());
}
if (diagram_.should_include(*concept_model)) {
if (diagram().should_include(*concept_model)) {
LOG_DBG("Adding concept {} with id {}", concept_model->full_name(false),
concept_model->id());
diagram_.add_concept(std::move(concept_model));
add_concept(std::move(concept_model));
}
else {
LOG_DBG("Skipping concept {} with id {}", concept_model->full_name(),
@@ -727,8 +730,8 @@ bool translation_unit_visitor::VisitCXXRecordDecl(clang::CXXRecordDecl *cls)
id_mapper().add(cls->getID(), cls_id);
auto &class_model = diagram().get_class(cls_id).has_value()
? *diagram().get_class(cls_id).get()
auto &class_model = diagram().find<class_>(cls_id).has_value()
? *diagram().find<class_>(cls_id).get()
: *c_ptr;
if (cls->isCompleteDefinition() && !class_model.complete())
@@ -741,11 +744,11 @@ bool translation_unit_visitor::VisitCXXRecordDecl(clang::CXXRecordDecl *cls)
}
forward_declarations_.erase(id);
if (diagram_.should_include(class_model)) {
if (diagram().should_include(class_model)) {
LOG_DBG("Adding class {} with id {}", class_model.full_name(false),
class_model.id());
diagram_.add_class(std::move(c_ptr));
add_class(std::move(c_ptr));
}
else {
LOG_DBG("Skipping class {} with id {}", class_model.full_name(),
@@ -896,11 +899,11 @@ void translation_unit_visitor::process_record_parent(
}
}
if (id_opt && diagram_.get_class(*id_opt)) {
if (id_opt && diagram_.find<class_>(*id_opt)) {
// Here we have 2 options, either:
// - the parent is a regular C++ class/struct
// - the parent is a class template declaration/specialization
auto parent_class = diagram_.get_class(*id_opt);
auto parent_class = diagram_.find<class_>(*id_opt);
c.set_namespace(parent_ns);
const auto cls_name = cls->getNameAsString();
@@ -1305,7 +1308,7 @@ void translation_unit_visitor::process_method(
.getUnqualifiedType()
->getAs<clang::TemplateSpecializationType>();
templ != nullptr) {
auto *unaliased_type = templ;
const auto *unaliased_type = templ;
if (unaliased_type->isTypeAlias())
unaliased_type = unaliased_type->getAliasedType()
->getAs<clang::TemplateSpecializationType>();
@@ -1320,7 +1323,7 @@ void translation_unit_visitor::process_method(
relationships.emplace_back(template_specialization_ptr->id(),
relationship_t::kDependency);
diagram().add_class(std::move(template_specialization_ptr));
add_class(std::move(template_specialization_ptr));
}
}
}
@@ -1657,7 +1660,7 @@ void translation_unit_visitor::process_function_parameter(
relationships.emplace_back(template_specialization_ptr->id(),
relationship_t::kDependency);
diagram().add_class(std::move(template_specialization_ptr));
add_class(std::move(template_specialization_ptr));
}
}
@@ -1686,12 +1689,8 @@ void translation_unit_visitor::ensure_lambda_type_is_relative(
std::string &parameter_type) const
{
#ifdef _MSC_VER
auto root_name = fmt::format(
"{}\\", std::filesystem::current_path().root_name().string());
if (root_name.back() == '\\') {
root_name.pop_back();
root_name.push_back('/');
}
auto root_name =
fmt::format("{}", std::filesystem::current_path().root_name().string());
#else
auto root_name = std::string{"/"};
#endif
@@ -1700,17 +1699,19 @@ void translation_unit_visitor::ensure_lambda_type_is_relative(
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));
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(std::filesystem::relative(
absolute_lambda_path, config().relative_to())
.string());
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,
@@ -1972,7 +1973,7 @@ void translation_unit_visitor::process_field(
// Add the template instantiation object to the diagram if it
// matches the include pattern
if (add_template_instantiation_to_diagram)
diagram().add_class(std::move(template_specialization_ptr));
add_class(std::move(template_specialization_ptr));
}
}
@@ -2004,7 +2005,7 @@ void translation_unit_visitor::add_incomplete_forward_declarations()
{
for (auto &[id, c] : forward_declarations_) {
if (diagram().should_include(c->full_name(false))) {
diagram().add_class(std::move(c));
add_class(std::move(c));
}
}
forward_declarations_.clear();
@@ -2092,4 +2093,61 @@ bool translation_unit_visitor::has_processed_template_class(
return util::contains(processed_template_qualified_names_, qualified_name);
}
void translation_unit_visitor::add_class(std::unique_ptr<class_> &&c)
{
if ((config().generate_packages() &&
config().package_type() == config::package_type_t::kDirectory)) {
assert(!c->file().empty());
const auto file = config().make_path_relative(c->file());
common::model::path p{
file.string(), common::model::path_type::kFilesystem};
p.pop_back();
diagram().add(p, std::move(c));
}
else {
diagram().add(c->path(), std::move(c));
}
}
void translation_unit_visitor::add_enum(std::unique_ptr<enum_> &&e)
{
if ((config().generate_packages() &&
config().package_type() == config::package_type_t::kDirectory)) {
assert(!e->file().empty());
const auto file = config().make_path_relative(e->file());
common::model::path p{
file.string(), common::model::path_type::kFilesystem};
p.pop_back();
diagram().add(p, std::move(e));
}
else {
diagram().add(e->path(), std::move(e));
}
}
void translation_unit_visitor::add_concept(std::unique_ptr<concept_> &&c)
{
if ((config().generate_packages() &&
config().package_type() == config::package_type_t::kDirectory)) {
assert(!c->file().empty());
const auto file = config().make_path_relative(c->file());
common::model::path p{
file.string(), common::model::path_type::kFilesystem};
p.pop_back();
diagram().add(p, std::move(c));
}
else {
diagram().add(c->path(), std::move(c));
}
}
} // namespace clanguml::class_diagram::visitor

13
src/class_diagram/visitor/translation_unit_visitor.h
View File

@@ -43,6 +43,7 @@ using clanguml::class_diagram::model::class_;
using clanguml::class_diagram::model::class_member;
using clanguml::class_diagram::model::class_method;
using clanguml::class_diagram::model::class_parent;
using clanguml::class_diagram::model::concept_;
using clanguml::class_diagram::model::diagram;
using clanguml::class_diagram::model::enum_;
using clanguml::class_diagram::model::method_parameter;
@@ -118,6 +119,14 @@ public:
*/
void finalize();
common::visitor::ast_id_mapper &id_mapper() const { return id_mapper_; }
void add_class(std::unique_ptr<class_> &&c);
void add_enum(std::unique_ptr<enum_> &&e);
void add_concept(std::unique_ptr<concept_> &&c);
void ensure_lambda_type_is_relative(std::string &parameter_type) const;
private:
bool should_include(const clang::NamedDecl *decl);
@@ -182,8 +191,6 @@ private:
const found_relationships_t &relationships,
bool break_on_first_aggregation = false);
void ensure_lambda_type_is_relative(std::string &parameter_type) const;
void process_record_parent(
clang::RecordDecl *cls, class_ &c, const namespace_ &ns);
@@ -218,8 +225,6 @@ private:
bool has_processed_template_class(const std::string &qualified_name) const;
common::visitor::ast_id_mapper &id_mapper() const { return id_mapper_; }
template_builder &tbuilder() { return template_builder_; }
// Reference to the output diagram model