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

Refactored nested diagrams with element_view template

Browse Source
This commit is contained in:
Bartek Kryza
2023-05-27 22:31:46 +02:00
parent ba32b54395
commit e6fa19ff39
10 changed files with 445 additions and 576 deletions
Download Patch File Download Diff File Expand all files Collapse all files

407
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,163 +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_class(
const common::model::path &parent_path, std::unique_ptr<class_> &&c)
{
if (parent_path.type() == common::model::path_type::kNamespace) {
return add_class_ns(std::move(c));
}
return add_class_fs(parent_path, std::move(c));
}
bool diagram::add_enum(const path &parent_path, std::unique_ptr<enum_> &&e)
{
if (parent_path.type() == common::model::path_type::kNamespace) {
return add_enum_ns(std::move(e));
}
return add_enum_fs(parent_path, std::move(e));
}
bool diagram::add_concept(
const path &parent_path, std::unique_ptr<concept_> &&c)
{
if (parent_path.type() == common::model::path_type::kNamespace) {
return add_concept_ns(std::move(c));
}
return add_concept_fs(parent_path, std::move(c));
}
bool diagram::add_package(
const path &parent_path, std::unique_ptr<common::model::package> &&p)
{
if (parent_path.type() == common::model::path_type::kNamespace) {
return add_package_ns(std::move(p));
}
return add_package_fs(parent_path, std::move(p));
}
bool diagram::add_package_fs(
const path &parent_path, std::unique_ptr<common::model::package> &&p)
{
LOG_DBG("Adding filesystem package: {}, {}", p->name(), p->full_name(true));
auto ns = p->get_relative_namespace();
return add_element(ns, std::move(p));
}
bool diagram::add_package_ns(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));
@@ -231,223 +93,16 @@ bool diagram::add_package_ns(std::unique_ptr<common::model::package> &&p)
return add_element(ns, std::move(p));
}
bool diagram::add_class_fs(
const common::model::path &parent_path, 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)
{
// 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>(c->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)));
LOG_DBG("Adding filesystem package: {}, {}", p->name(), p->full_name(true));
add_package_fs(ns, std::move(pkg));
}
auto ns = p->get_relative_namespace();
const auto base_name = c->name();
const auto full_name = c->full_name(false);
const auto id = c->id();
auto cc = std::ref(*c);
if (add_element(parent_path, std::move(c))) {
classes_.push_back(cc);
return true;
}
else {
LOG_WARN("Cannot add class {} with id {} due to: {}", base_name, id);
}
return false;
}
bool diagram::add_class_ns(std::unique_ptr<class_> &&c)
{
const auto base_name = c->name();
const auto full_name = c->full_name(false);
LOG_DBG("Adding class: {}::{}, {}", 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_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 class {} 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_ns(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_enum_fs(
const common::model::path &parent_path, std::unique_ptr<enum_> &&e)
{
// 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_package_fs(ns, std::move(pkg));
}
const auto base_name = e->name();
const auto full_name = e->full_name(false);
const auto id = e->id();
auto &cc = *e;
if (add_element(parent_path, std::move(e))) {
enums_.push_back(std::ref(cc));
return true;
}
else {
LOG_WARN("Cannot add class {} with id {} due to: {}", base_name, id);
}
return false;
}
bool diagram::add_concept_ns(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;
}
bool diagram::add_concept_fs(
const common::model::path &parent_path, std::unique_ptr<concept_> &&c)
{
// 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>(c->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_package_fs(ns, std::move(pkg));
}
const auto base_name = c->name();
const auto full_name = c->full_name(false);
const auto id = c->id();
auto &cc = *c;
if (add_element(parent_path, std::move(c))) {
concepts_.push_back(std::ref(cc));
return true;
}
LOG_WARN("Cannot add class {} with id {} due to: {}", base_name, id);
return false;
return add_element(ns, std::move(p));
}
void diagram::get_parents(
@@ -456,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()));
@@ -474,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; });
}
@@ -489,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();
}

203
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"
@@ -34,6 +35,7 @@ namespace clanguml::class_diagram::model {
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;
@@ -41,7 +43,11 @@ using nested_trait_ns =
clanguml::common::model::nested_trait<clanguml::common::model::element,
clanguml::common::model::namespace_>;
class diagram : public common::model::diagram::diagram, public nested_trait_ns {
class diagram : public common::model::diagram::diagram,
public element_view<class_>,
public element_view<enum_>,
public element_view<concept_>,
public nested_trait_ns {
public:
diagram() = default;
@@ -62,32 +68,23 @@ 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;
opt_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));
}
opt_ref<class_> get_class(diagram_element::id_t id) const;
opt_ref<enum_> get_enum(const std::string &name) const;
opt_ref<enum_> get_enum(diagram_element::id_t id) const;
opt_ref<concept_> get_concept(const std::string &name) const;
opt_ref<concept_> get_concept(diagram_element::id_t id) const;
bool add_class(const path &parent_path, std::unique_ptr<class_> &&c);
bool add_enum(const path &parent_path, std::unique_ptr<enum_> &&e);
bool add_concept(const path &parent_path, std::unique_ptr<concept_> &&e);
bool add_package(
const path &parent_path, std::unique_ptr<common::model::package> &&p);
return add_with_filesystem_path(parent_path, std::move(e));
}
std::string to_alias(diagram_element::id_t id) const;
@@ -100,28 +97,148 @@ public:
inja::json context() const override;
private:
bool add_class_ns(std::unique_ptr<class_> &&c);
bool add_class_fs(
const common::model::path &parent_path, std::unique_ptr<class_> &&c);
template <typename ElementT>
bool add_with_namespace_path(std::unique_ptr<ElementT> &&e);
bool add_enum_ns(std::unique_ptr<enum_> &&c);
bool add_enum_fs(
const common::model::path &parent_path, std::unique_ptr<enum_> &&c);
bool add_package_ns(std::unique_ptr<common::model::package> &&p);
bool add_package_fs(const common::model::path &parent_path,
std::unique_ptr<common::model::package> &&p);
bool add_concept_ns(std::unique_ptr<concept_> &&p);
bool add_concept_fs(
const common::model::path &parent_path, std::unique_ptr<concept_> &&p);
common::reference_vector<class_> classes_;
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);
const auto id = e->id();
auto &e_ref = *e;
if (add_element(parent_path, std::move(e))) {
element_view<ElementT>::add(std::ref(e_ref));
return true;
}
LOG_WARN(
"Cannot add {} {} with id {} due to: {}", element_type, base_name, id);
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 {

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

@@ -84,7 +84,7 @@ bool translation_unit_visitor::VisitNamespaceDecl(clang::NamespaceDecl *ns)
}
if (!p->skip()) {
diagram().add_package(package_path, std::move(p));
diagram().add(package_path, std::move(p));
}
}
@@ -140,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());
@@ -364,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()) {
@@ -730,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())
@@ -899,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();
@@ -2105,10 +2105,10 @@ void translation_unit_visitor::add_class(std::unique_ptr<class_> &&c)
common::model::path p{file, common::model::path_type::kFilesystem};
p.pop_back();
diagram().add_class(p, std::move(c));
diagram().add(p, std::move(c));
}
else {
diagram().add_class(c->path(), std::move(c));
diagram().add(c->path(), std::move(c));
}
}
@@ -2123,10 +2123,10 @@ void translation_unit_visitor::add_enum(std::unique_ptr<enum_> &&e)
common::model::path p{file, common::model::path_type::kFilesystem};
p.pop_back();
diagram().add_enum(p, std::move(e));
diagram().add(p, std::move(e));
}
else {
diagram().add_enum(e->path(), std::move(e));
diagram().add(e->path(), std::move(e));
}
}
@@ -2141,10 +2141,10 @@ void translation_unit_visitor::add_concept(std::unique_ptr<concept_> &&c)
common::model::path p{file, common::model::path_type::kFilesystem};
p.pop_back();
diagram().add_concept(p, std::move(c));
diagram().add(p, std::move(c));
}
else {
diagram().add_concept(c->path(), std::move(c));
diagram().add(c->path(), std::move(c));
}
}