From 3430d5422ad2a90edfda72663ebebc39a7231bdf Mon Sep 17 00:00:00 2001 From: Bartek Kryza Date: Mon, 5 Jun 2023 22:44:27 +0200 Subject: [PATCH 01/15] Added Ubuntu Lunar packaging spec --- packaging/debian/control.lunar | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) create mode 100644 packaging/debian/control.lunar diff --git a/packaging/debian/control.lunar b/packaging/debian/control.lunar new file mode 100644 index 00000000..73dbef07 --- /dev/null +++ b/packaging/debian/control.lunar @@ -0,0 +1,19 @@ +Source: clang-uml +Maintainer: Bartek Kryza +Section: devel +Priority: optional +Build-Depends: debhelper, git, make, gcc, g++, cmake (>= 3.16), libyaml-cpp-dev, llvm-16, llvm-16-dev, clang-16, clang-tools-16, libclang-16-dev, libclang-cpp16-dev, libmlir-16-dev, mlir-16-tools +Standards-Version: 4.3.0 +Vcs-Browser: https://github.com/bkryza/clang-uml +Vcs-Git: https://github.com/bkryza/clang-uml.git +Homepage: https://github.com/bkryza/clang-uml + + +Package: clang-uml +Architecture: any +Section: utils +Depends: ${misc:Depends}, ${shlibs:Depends}, clang-16 +Pre-Depends: ${misc:Pre-Depends} +Description: Automatic C++ UML diagram generator based on Clang. + . + This package provides the clang-uml binary. From 399b7e1907e475a4d0ee5f24b4fea43db04eba8e Mon Sep 17 00:00:00 2001 From: Bartek Kryza Date: Mon, 5 Jun 2023 23:05:35 +0200 Subject: [PATCH 02/15] Added regex support to elements filter --- src/common/model/diagram_filter.cc | 7 +-- src/common/model/diagram_filter.h | 5 +- src/config/config.cc | 4 ++ src/config/config.h | 77 +++++++++++++++++++++++++++++- src/config/yaml_decoders.cc | 18 +++++++ src/config/yaml_emitters.cc | 13 +++++ tests/test_config_data/filters.yml | 12 ++++- tests/test_filters.cc | 41 ++++++++++++++++ 8 files changed, 170 insertions(+), 7 deletions(-) diff --git a/src/common/model/diagram_filter.cc b/src/common/model/diagram_filter.cc index 2ff3801c..37fcc7bb 100644 --- a/src/common/model/diagram_filter.cc +++ b/src/common/model/diagram_filter.cc @@ -216,7 +216,8 @@ tvl::value_t namespace_filter::match( [&e](const auto &nsit) { return e.get_namespace().starts_with(nsit); }); } -element_filter::element_filter(filter_t type, std::vector elements) +element_filter::element_filter( + filter_t type, std::vector elements) : filter_visitor{type} , elements_{std::move(elements)} { @@ -227,8 +228,8 @@ tvl::value_t element_filter::match( { return tvl::any_of( elements_.begin(), elements_.end(), [&e](const auto &el) { - return (e.full_name(false) == el) || - (fmt::format("::{}", e.full_name(false)) == el); + return ((el == e.full_name(false)) || + (el == fmt::format("::{}", e.full_name(false)))); }); } diff --git a/src/common/model/diagram_filter.h b/src/common/model/diagram_filter.h index d772602e..e710a592 100644 --- a/src/common/model/diagram_filter.h +++ b/src/common/model/diagram_filter.h @@ -125,14 +125,15 @@ private: }; struct element_filter : public filter_visitor { - element_filter(filter_t type, std::vector elements); + element_filter( + filter_t type, std::vector elements); ~element_filter() override = default; tvl::value_t match(const diagram &d, const element &e) const override; private: - std::vector elements_; + std::vector elements_; }; struct element_type_filter : public filter_visitor { diff --git a/src/config/config.cc b/src/config/config.cc index 95bd25bd..44ebafb0 100644 --- a/src/config/config.cc +++ b/src/config/config.cc @@ -24,6 +24,8 @@ namespace clanguml::config { +std::string to_string(const std::string &s) { return s; } + std::string to_string(const hint_t t) { switch (t) { @@ -85,6 +87,8 @@ std::string to_string(method_type mt) } } +std::string to_string(string_or_regex sr) { return sr.to_string(); } + std::string to_string(const comment_parser_t cp) { switch (cp) { diff --git a/src/config/config.h b/src/config/config.h index 03fa5689..8df435bc 100644 --- a/src/config/config.h +++ b/src/config/config.h @@ -28,6 +28,7 @@ #include #include #include +#include #include #include #include @@ -35,6 +36,80 @@ namespace clanguml { namespace config { +std::string to_string(const std::string &s); + +/** + * @brief Wrapper around std::regex, which contains original pattern + */ +struct regex { + regex(std::regex r, std::string p) + : regexp{std::move(r)} + , pattern{std::move(p)} + { + } + + [[nodiscard]] bool operator==(const std::string &v) + { + return std::regex_match(v, regexp); + } + + std::regex regexp; + std::string pattern; +}; + +template struct or_regex { + or_regex() = default; + + or_regex(T v) + : value_{std::move(v)} + { + } + + or_regex(std::regex r, std::string p) + : value_{regex{std::move(r), std::move(p)}} + { + } + + or_regex &operator=(const T &v) + { + value_ = v; + return *this; + } + + or_regex &operator=(const regex &v) + { + value_ = v; + return *this; + } + + [[nodiscard]] bool operator==(const T &v) const + { + if (std::holds_alternative(value_)) + return std::regex_match(v, std::get(value_).regexp); + + return std::get(value_) == v; + } + + std::string to_string() const + { + if (std::holds_alternative(value_)) + return std::get(value_).pattern; + + return clanguml::config::to_string(std::get(value_)); + } + + const std::variant &value() const { return value_; } + +private: + std::variant value_; +}; + +using string_or_regex = or_regex; + +std::string to_string(string_or_regex sr); + +using namespace_or_regex = std::variant; + enum class method_arguments { full, abbreviated, none }; enum class method_type { @@ -75,7 +150,7 @@ struct diagram_template { struct filter { std::vector namespaces; - std::vector elements; + std::vector elements; // E.g.: // - class diff --git a/src/config/yaml_decoders.cc b/src/config/yaml_decoders.cc index 2ecbd1b1..6784a941 100644 --- a/src/config/yaml_decoders.cc +++ b/src/config/yaml_decoders.cc @@ -41,6 +41,7 @@ using clanguml::config::plantuml; using clanguml::config::relationship_hint_t; using clanguml::config::sequence_diagram; using clanguml::config::source_location; +using clanguml::config::string_or_regex; inline bool has_key(const YAML::Node &n, const std::string &key) { @@ -342,6 +343,23 @@ template <> struct convert { } }; +template <> struct convert { + static bool decode(const Node &node, string_or_regex &rhs) + { + using namespace std::string_literals; + if (node.IsMap()) { + auto pattern = node["r"].as(); + auto rx = std::regex(pattern); + rhs = string_or_regex{std::move(rx), std::move(pattern)}; + } + else { + rhs = string_or_regex{node.as()}; + } + + return true; + } +}; + // // filter Yaml decoder // diff --git a/src/config/yaml_emitters.cc b/src/config/yaml_emitters.cc index 6685e6ca..53967d36 100644 --- a/src/config/yaml_emitters.cc +++ b/src/config/yaml_emitters.cc @@ -52,6 +52,19 @@ YAML::Emitter &operator<<(YAML::Emitter &out, const method_type &m) return out; } +YAML::Emitter &operator<<(YAML::Emitter &out, const string_or_regex &m) +{ + if (std::holds_alternative(m.value())) { + out << std::get(m.value()); + } + else { + out << YAML::Key << "r" << YAML::Value + << std::get(m.value()).pattern; + } + + return out; +} + YAML::Emitter &operator<<(YAML::Emitter &out, const filter &f) { out << YAML::BeginMap; diff --git a/tests/test_config_data/filters.yml b/tests/test_config_data/filters.yml index 1ebea071..13be39a6 100644 --- a/tests/test_config_data/filters.yml +++ b/tests/test_config_data/filters.yml @@ -29,4 +29,14 @@ diagrams: exclude: method_types: - deleted - - destructor \ No newline at end of file + - destructor + regex_elements_test: + type: class + include: + elements: + - ns1::ClassA + - r: 'ns1::ns2::Class.+' + - r: 'ns1::.+::ns3::.+' + exclude: + elements: + - ns1::ns2::ClassZ \ No newline at end of file diff --git a/tests/test_filters.cc b/tests/test_filters.cc index 4f1764ba..75c03741 100644 --- a/tests/test_filters.cc +++ b/tests/test_filters.cc @@ -19,6 +19,7 @@ #include "catch.h" +#include "class_diagram/model/class.h" #include "common/model/diagram_filter.h" #include "common/model/source_file.h" #include "config/config.h" @@ -103,4 +104,44 @@ TEST_CASE("Test method_types exclude filter", "[unit-test]") cm.is_destructor(true); CHECK(!filter.should_include(cm)); +} + +TEST_CASE("Test elements regexp filter", "[unit-test]") +{ + using clanguml::class_diagram::model::class_method; + using clanguml::common::model::access_t; + using clanguml::common::model::diagram_filter; + using clanguml::common::model::namespace_; + using clanguml::common::model::source_file; + + using clanguml::class_diagram::model::class_; + + auto cfg = clanguml::config::load("./test_config_data/filters.yml"); + + auto &config = *cfg.diagrams["regex_elements_test"]; + clanguml::class_diagram::model::diagram diagram; + + diagram_filter filter(diagram, config); + + class_ c{{}}; + + c.set_namespace(namespace_{"ns1"}); + c.set_name("ClassA"); + + CHECK(filter.should_include(c)); + + c.set_namespace(namespace_{"ns1::ns2"}); + c.set_name("ClassA"); + + CHECK(filter.should_include(c)); + + c.set_namespace(namespace_{"ns1::ns2"}); + c.set_name("ClassZ"); + + CHECK(!filter.should_include(c)); + + c.set_namespace(namespace_{"ns1::ns5::ns3"}); + c.set_name("ClassA"); + + CHECK(filter.should_include(c)); } \ No newline at end of file From c7e61a586b6a00842e7ba4b325376c9f5afd7e5f Mon Sep 17 00:00:00 2001 From: Bartek Kryza Date: Tue, 6 Jun 2023 21:31:50 +0200 Subject: [PATCH 03/15] Added regex support to namespaces filter --- src/common/model/diagram_filter.cc | 66 ++++++++++++++++++++++-------- src/common/model/diagram_filter.h | 5 ++- src/config/config.h | 6 +-- src/config/yaml_decoders.cc | 20 ++++++++- src/config/yaml_emitters.cc | 13 ++++++ tests/t00002/test_case.h | 3 -- tests/test_config_data/filters.yml | 11 ++++- tests/test_filters.cc | 58 ++++++++++++++++++++++++++ 8 files changed, 154 insertions(+), 28 deletions(-) diff --git a/src/common/model/diagram_filter.cc b/src/common/model/diagram_filter.cc index 37fcc7bb..468b14b1 100644 --- a/src/common/model/diagram_filter.cc +++ b/src/common/model/diagram_filter.cc @@ -173,7 +173,7 @@ tvl::value_t anyof_filter::match( } namespace_filter::namespace_filter( - filter_t type, std::vector namespaces) + filter_t type, std::vector namespaces) : filter_visitor{type} , namespaces_{std::move(namespaces)} { @@ -185,8 +185,17 @@ tvl::value_t namespace_filter::match( if (ns.is_empty()) return {}; - return tvl::any_of(namespaces_.begin(), namespaces_.end(), - [&ns](const auto &nsit) { return ns.starts_with(nsit) || ns == nsit; }); + return tvl::any_of( + namespaces_.begin(), namespaces_.end(), [&ns](const auto &nsit) { + if (std::holds_alternative(nsit.value())) { + const auto &ns_pattern = std::get(nsit.value()); + return ns.starts_with(ns_pattern) || ns == ns_pattern; + } + else { + const auto ®ex = std::get(nsit.value()); + return regex == ns.to_string(); + } + }); } tvl::value_t namespace_filter::match( @@ -195,25 +204,45 @@ tvl::value_t namespace_filter::match( if (dynamic_cast(&e) != nullptr) { return tvl::any_of(namespaces_.begin(), namespaces_.end(), [&e, is_inclusive = is_inclusive()](const auto &nsit) { - auto element_full_name_starts_with_namespace = - (e.get_namespace() | e.name()).starts_with(nsit); - auto element_full_name_equals_pattern = - (e.get_namespace() | e.name()) == nsit; - auto namespace_starts_with_element_qualified_name = - nsit.starts_with(e.get_namespace()); + if (std::holds_alternative(nsit.value())) { + const auto &ns_pattern = std::get(nsit.value()); - auto result = element_full_name_starts_with_namespace || - element_full_name_equals_pattern; + auto element_full_name_starts_with_namespace = + (e.get_namespace() | e.name()).starts_with(ns_pattern); - if (is_inclusive) - result = - result || namespace_starts_with_element_qualified_name; + auto element_full_name_equals_pattern = + (e.get_namespace() | e.name()) == ns_pattern; - return result; + auto namespace_starts_with_element_qualified_name = + ns_pattern.starts_with(e.get_namespace()); + + auto result = element_full_name_starts_with_namespace || + element_full_name_equals_pattern; + + if (is_inclusive) + result = result || + namespace_starts_with_element_qualified_name; + + return result; + } + else { + return std::get(nsit.value()) == + e.full_name(false); + } }); } - return tvl::any_of(namespaces_.begin(), namespaces_.end(), - [&e](const auto &nsit) { return e.get_namespace().starts_with(nsit); }); + + return tvl::any_of( + namespaces_.begin(), namespaces_.end(), [&e](const auto &nsit) { + if (std::holds_alternative(nsit.value())) { + return e.get_namespace().starts_with( + std::get(nsit.value())); + } + else { + return std::get(nsit.value()) == + e.full_name(false); + } + }); } element_filter::element_filter( @@ -524,7 +553,8 @@ tvl::value_t paths_filter::match( auto sl_path = std::filesystem::path{p.file()}; - // Matching source paths doesn't make sens if they are not absolute or empty + // Matching source paths doesn't make sens if they are not absolute or + // empty if (p.file().empty() || sl_path.is_relative()) { return {}; } diff --git a/src/common/model/diagram_filter.h b/src/common/model/diagram_filter.h index e710a592..61080871 100644 --- a/src/common/model/diagram_filter.h +++ b/src/common/model/diagram_filter.h @@ -112,7 +112,8 @@ private: }; struct namespace_filter : public filter_visitor { - namespace_filter(filter_t type, std::vector namespaces); + namespace_filter( + filter_t type, std::vector namespaces); ~namespace_filter() override = default; @@ -121,7 +122,7 @@ struct namespace_filter : public filter_visitor { tvl::value_t match(const diagram &d, const element &e) const override; private: - std::vector namespaces_; + std::vector namespaces_; }; struct element_filter : public filter_visitor { diff --git a/src/config/config.h b/src/config/config.h index 8df435bc..ee649e02 100644 --- a/src/config/config.h +++ b/src/config/config.h @@ -48,7 +48,7 @@ struct regex { { } - [[nodiscard]] bool operator==(const std::string &v) + [[nodiscard]] bool operator==(const std::string &v) const { return std::regex_match(v, regexp); } @@ -108,7 +108,7 @@ using string_or_regex = or_regex; std::string to_string(string_or_regex sr); -using namespace_or_regex = std::variant; +using namespace_or_regex = or_regex; enum class method_arguments { full, abbreviated, none }; @@ -148,7 +148,7 @@ struct diagram_template { }; struct filter { - std::vector namespaces; + std::vector namespaces; std::vector elements; diff --git a/src/config/yaml_decoders.cc b/src/config/yaml_decoders.cc index 6784a941..b6701079 100644 --- a/src/config/yaml_decoders.cc +++ b/src/config/yaml_decoders.cc @@ -35,6 +35,7 @@ using clanguml::config::location_t; using clanguml::config::member_order_t; using clanguml::config::method_arguments; using clanguml::config::method_type; +using clanguml::config::namespace_or_regex; using clanguml::config::package_diagram; using clanguml::config::package_type_t; using clanguml::config::plantuml; @@ -360,6 +361,23 @@ template <> struct convert { } }; +template <> struct convert { + static bool decode(const Node &node, namespace_or_regex &rhs) + { + using namespace std::string_literals; + if (node.IsMap()) { + auto pattern = node["r"].as(); + auto rx = std::regex(pattern); + rhs = namespace_or_regex{std::move(rx), std::move(pattern)}; + } + else { + rhs = namespace_or_regex{node.as()}; + } + + return true; + } +}; + // // filter Yaml decoder // @@ -368,7 +386,7 @@ template <> struct convert { { if (node["namespaces"]) { auto namespace_list = - node["namespaces"].as>(); + node["namespaces"].as(); for (const auto &ns : namespace_list) rhs.namespaces.push_back({ns}); } diff --git a/src/config/yaml_emitters.cc b/src/config/yaml_emitters.cc index 53967d36..20f883c4 100644 --- a/src/config/yaml_emitters.cc +++ b/src/config/yaml_emitters.cc @@ -65,6 +65,19 @@ YAML::Emitter &operator<<(YAML::Emitter &out, const string_or_regex &m) return out; } +YAML::Emitter &operator<<(YAML::Emitter &out, const namespace_or_regex &m) +{ + if (std::holds_alternative(m.value())) { + out << std::get(m.value()); + } + else { + out << YAML::Key << "r" << YAML::Value + << std::get(m.value()).pattern; + } + + return out; +} + YAML::Emitter &operator<<(YAML::Emitter &out, const filter &f) { out << YAML::BeginMap; diff --git a/tests/t00002/test_case.h b/tests/t00002/test_case.h index a4f5e69f..3b612247 100644 --- a/tests/t00002/test_case.h +++ b/tests/t00002/test_case.h @@ -25,9 +25,6 @@ TEST_CASE("t00002", "[test-case][class]") REQUIRE(diagram->name == "t00002_class"); REQUIRE(diagram->include().namespaces.size() == 1); - REQUIRE_THAT(diagram->include().namespaces, - VectorContains( - clanguml::common::model::namespace_{"clanguml::t00002"})); REQUIRE(diagram->exclude().namespaces.size() == 0); diff --git a/tests/test_config_data/filters.yml b/tests/test_config_data/filters.yml index 13be39a6..7ebf5258 100644 --- a/tests/test_config_data/filters.yml +++ b/tests/test_config_data/filters.yml @@ -39,4 +39,13 @@ diagrams: - r: 'ns1::.+::ns3::.+' exclude: elements: - - ns1::ns2::ClassZ \ No newline at end of file + - ns1::ns2::ClassZ + regex_namespace_test: + type: class + include: + namespaces: + - ns1::ns2 + - r: '.*interface.*' + exclude: + namespaces: + - r: '.*detail.*' \ No newline at end of file diff --git a/tests/test_filters.cc b/tests/test_filters.cc index 75c03741..fa1316e0 100644 --- a/tests/test_filters.cc +++ b/tests/test_filters.cc @@ -144,4 +144,62 @@ TEST_CASE("Test elements regexp filter", "[unit-test]") c.set_name("ClassA"); CHECK(filter.should_include(c)); +} + +TEST_CASE("Test namespaces regexp filter", "[unit-test]") +{ + using clanguml::class_diagram::model::class_method; + using clanguml::common::model::access_t; + using clanguml::common::model::diagram_filter; + using clanguml::common::model::namespace_; + using clanguml::common::model::package; + using clanguml::common::model::source_file; + + using clanguml::class_diagram::model::class_; + + auto cfg = clanguml::config::load("./test_config_data/filters.yml"); + + auto &config = *cfg.diagrams["regex_namespace_test"]; + clanguml::class_diagram::model::diagram diagram; + + diagram_filter filter(diagram, config); + + class_ c{{}}; + + c.set_namespace(namespace_{"ns1::ns2"}); + c.set_name("ClassA"); + + CHECK(filter.should_include(c)); + + c.set_namespace(namespace_{"ns1::ns2::detail"}); + c.set_name("ClassAImpl"); + + CHECK(!filter.should_include(c)); + + c.set_namespace(namespace_{"ns1::interface"}); + c.set_name("IClassA"); + + CHECK(filter.should_include(c)); + + CHECK(!filter.should_include(namespace_{"ns1"})); + CHECK(filter.should_include(namespace_{"ns1::ns2"})); + CHECK(!filter.should_include(namespace_{"ns1::ns2::detail"})); + CHECK(filter.should_include(namespace_{"ns1::interface"})); + + package p{{}}; + + p.set_namespace({"ns1"}); + p.set_name("ns2"); + + CHECK(filter.should_include(p)); + + p.set_namespace({"ns1::ns2"}); + p.set_name("detail"); + + CHECK(!filter.should_include(p)); + + p.set_namespace({"ns1"}); + p.set_name("interface"); + + CHECK(filter.should_include(p)); } \ No newline at end of file From ad2fc3f8a6f3236b2497fa1b70db287adb0b2bd5 Mon Sep 17 00:00:00 2001 From: Bartek Kryza Date: Wed, 7 Jun 2023 00:15:36 +0200 Subject: [PATCH 04/15] Added regex support to subclasses filter --- src/class_diagram/model/class_parent.h | 8 ++ src/common/model/diagram_filter.cc | 3 +- src/common/model/diagram_filter.h | 4 +- src/config/config.h | 2 +- tests/test_config_data/filters.yml | 7 +- tests/test_filters.cc | 145 ++++++++++++++++++++++++- 6 files changed, 162 insertions(+), 7 deletions(-) diff --git a/src/class_diagram/model/class_parent.h b/src/class_diagram/model/class_parent.h index 79c872c9..35af3dec 100644 --- a/src/class_diagram/model/class_parent.h +++ b/src/class_diagram/model/class_parent.h @@ -17,6 +17,7 @@ */ #pragma once +#include "common/clang_utils.h" #include "common/model/enums.h" #include "common/types.h" @@ -26,6 +27,13 @@ namespace clanguml::class_diagram::model { class class_parent { public: + class_parent() = default; + class_parent(const std::string &name) + { + set_name(name); + set_id(common::to_id(name)); + } + void set_name(const std::string &name); std::string name() const; diff --git a/src/common/model/diagram_filter.cc b/src/common/model/diagram_filter.cc index 468b14b1..96831ceb 100644 --- a/src/common/model/diagram_filter.cc +++ b/src/common/model/diagram_filter.cc @@ -311,7 +311,8 @@ tvl::value_t method_type_filter::match( }); } -subclass_filter::subclass_filter(filter_t type, std::vector roots) +subclass_filter::subclass_filter( + filter_t type, std::vector roots) : filter_visitor{type} , roots_{std::move(roots)} { diff --git a/src/common/model/diagram_filter.h b/src/common/model/diagram_filter.h index 61080871..a90cb1e5 100644 --- a/src/common/model/diagram_filter.h +++ b/src/common/model/diagram_filter.h @@ -162,14 +162,14 @@ private: }; struct subclass_filter : public filter_visitor { - subclass_filter(filter_t type, std::vector roots); + subclass_filter(filter_t type, std::vector roots); ~subclass_filter() override = default; tvl::value_t match(const diagram &d, const element &e) const override; private: - std::vector roots_; + std::vector roots_; }; struct parents_filter : public filter_visitor { diff --git a/src/config/config.h b/src/config/config.h index ee649e02..0355fe1e 100644 --- a/src/config/config.h +++ b/src/config/config.h @@ -170,7 +170,7 @@ struct filter { // - private std::vector access; - std::vector subclasses; + std::vector subclasses; std::vector parents; diff --git a/tests/test_config_data/filters.yml b/tests/test_config_data/filters.yml index 7ebf5258..30cb9cad 100644 --- a/tests/test_config_data/filters.yml +++ b/tests/test_config_data/filters.yml @@ -48,4 +48,9 @@ diagrams: - r: '.*interface.*' exclude: namespaces: - - r: '.*detail.*' \ No newline at end of file + - r: '.*detail.*' + regex_subclasses_test: + type: class + include: + subclasses: + - r: 'ns1::ns2::Base[A|B]' \ No newline at end of file diff --git a/tests/test_filters.cc b/tests/test_filters.cc index fa1316e0..96757606 100644 --- a/tests/test_filters.cc +++ b/tests/test_filters.cc @@ -15,11 +15,14 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -#define CATCH_CONFIG_MAIN + +#define CATCH_CONFIG_RUNNER +#define CATCH_CONFIG_CONSOLE_WIDTH 512 #include "catch.h" #include "class_diagram/model/class.h" +#include "cli/cli_handler.h" #include "common/model/diagram_filter.h" #include "common/model/source_file.h" #include "config/config.h" @@ -149,6 +152,7 @@ TEST_CASE("Test elements regexp filter", "[unit-test]") TEST_CASE("Test namespaces regexp filter", "[unit-test]") { using clanguml::class_diagram::model::class_method; + using clanguml::class_diagram::model::class_parent; using clanguml::common::model::access_t; using clanguml::common::model::diagram_filter; using clanguml::common::model::namespace_; @@ -202,4 +206,141 @@ TEST_CASE("Test namespaces regexp filter", "[unit-test]") p.set_name("interface"); CHECK(filter.should_include(p)); -} \ No newline at end of file +} + +TEST_CASE("Test subclasses regexp filter", "[unit-test]") +{ + using clanguml::class_diagram::model::class_method; + using clanguml::class_diagram::model::class_parent; + using clanguml::common::to_id; + using clanguml::common::model::access_t; + using clanguml::common::model::diagram_filter; + using clanguml::common::model::namespace_; + using clanguml::common::model::package; + using clanguml::common::model::source_file; + using namespace std::string_literals; + + using clanguml::class_diagram::model::class_; + + auto cfg = clanguml::config::load("./test_config_data/filters.yml"); + + auto &config = *cfg.diagrams["regex_subclasses_test"]; + clanguml::class_diagram::model::diagram diagram; + + auto p = std::make_unique(config.using_namespace()); + p->set_namespace({}); + p->set_name("ns1"); + diagram.add({}, std::move(p)); + p = std::make_unique(config.using_namespace()); + p->set_namespace({"ns1"}); + p->set_name("ns2"); + diagram.add(namespace_{"ns1"}, std::move(p)); + + auto c = std::make_unique(config.using_namespace()); + c->set_namespace(namespace_{"ns1::ns2"}); + c->set_name("BaseA"); + c->set_id(to_id("ns1::ns2::BaseA"s)); + diagram.add(namespace_{"ns1::ns2"}, std::move(c)); + + c = std::make_unique(config.using_namespace()); + c->set_namespace(namespace_{"ns1::ns2"}); + c->set_name("A1"); + c->set_id(to_id("ns1::ns2::A1"s)); + c->add_parent({"ns1::ns2::BaseA"}); + diagram.add(namespace_{"ns1::ns2"}, std::move(c)); + + c = std::make_unique(config.using_namespace()); + c->set_namespace(namespace_{"ns1::ns2"}); + c->set_name("A2"); + c->set_id(to_id("ns1::ns2::A2"s)); + c->add_parent({"ns1::ns2::BaseA"}); + diagram.add(namespace_{"ns1::ns2"}, std::move(c)); + + c = std::make_unique(config.using_namespace()); + c->set_namespace(namespace_{"ns1::ns2"}); + c->set_name("BaseB"); + c->set_id(to_id("ns1::ns2::BaseB"s)); + diagram.add(namespace_{"ns1::ns2"}, std::move(c)); + + c = std::make_unique(config.using_namespace()); + c->set_namespace(namespace_{"ns1::ns2"}); + c->set_name("B1"); + c->set_id(to_id("ns1::ns2::B1"s)); + c->add_parent({"ns1::ns2::BaseB"}); + diagram.add(namespace_{"ns1::ns2"}, std::move(c)); + + c = std::make_unique(config.using_namespace()); + c->set_namespace(namespace_{"ns1::ns2"}); + c->set_name("B2"); + c->set_id(to_id("ns1::ns2::B2"s)); + c->add_parent({"ns1::ns2::BaseB"}); + diagram.add(namespace_{"ns1::ns2"}, std::move(c)); + + c = std::make_unique(config.using_namespace()); + c->set_namespace(namespace_{"ns1::ns2"}); + c->set_name("Common"); + c->set_id(to_id("ns1::ns2::Common"s)); + diagram.add(namespace_{"ns1::ns2"}, std::move(c)); + + c = std::make_unique(config.using_namespace()); + c->set_namespace(namespace_{"ns1::ns2"}); + c->set_name("C1"); + c->set_id(to_id("ns1::ns2::C1"s)); + c->add_parent({"ns1::ns2::Common"}); + diagram.add(namespace_{"ns1::ns2"}, std::move(c)); + + diagram.set_complete(true); + + diagram_filter filter(diagram, config); + + c = std::make_unique(config.using_namespace()); + c->set_namespace(namespace_{"ns1::ns2"}); + c->set_name("A1"); + c->set_id(to_id("ns1::ns2::A1"s)); + CHECK(filter.should_include(*c)); + + c = std::make_unique(config.using_namespace()); + c->set_namespace(namespace_{"ns1::ns2"}); + c->set_name("B1"); + c->set_id(to_id("ns1::ns2::B1"s)); + CHECK(filter.should_include(*c)); + + c = std::make_unique(config.using_namespace()); + c->set_namespace(namespace_{"ns1::ns2"}); + c->set_name("C1"); + c->set_id(to_id("ns1::ns2::C1"s)); + CHECK(!filter.should_include(*c)); +} + +/// +/// Main test function +/// +int main(int argc, char *argv[]) +{ + Catch::Session session; + using namespace Catch::clara; + + bool debug_log{false}; + auto cli = session.cli() | + Opt(debug_log, "debug_log")["-u"]["--debug-log"]("Enable debug logs"); + + session.cli(cli); + + int returnCode = session.applyCommandLine(argc, argv); + if (returnCode != 0) + return returnCode; + + clanguml::cli::cli_handler clih; + + std::vector argvv = { + "clang-uml", "--config", "./test_config_data/simple.yml"}; + + if (debug_log) + argvv.push_back("-vvv"); + else + argvv.push_back("-q"); + + clih.handle_options(argvv.size(), argvv.data()); + + return session.run(); +} From b3b95efb653602dfae5f3de2724d1cdb33677114 Mon Sep 17 00:00:00 2001 From: Bartek Kryza Date: Thu, 8 Jun 2023 00:03:27 +0200 Subject: [PATCH 05/15] Added regex support to parents filter --- src/class_diagram/model/diagram.h | 23 +++++++ src/common/model/diagram_filter.cc | 27 ++++---- src/common/model/diagram_filter.h | 16 ++--- src/common/types.cc | 27 ++++++++ src/common/types.h | 80 +++++++++++++++++++++- src/config/config.cc | 4 -- src/config/config.h | 83 ++--------------------- src/config/yaml_decoders.cc | 4 +- src/config/yaml_emitters.cc | 70 ++++++++++--------- tests/test_config_data/filters.yml | 7 +- tests/test_filters.cc | 104 +++++++++++++++++++++++++++++ 11 files changed, 306 insertions(+), 139 deletions(-) create mode 100644 src/common/types.cc diff --git a/src/class_diagram/model/diagram.h b/src/class_diagram/model/diagram.h index 734ab2f5..8efd5969 100644 --- a/src/class_diagram/model/diagram.h +++ b/src/class_diagram/model/diagram.h @@ -24,8 +24,10 @@ #include "common/model/package.h" #include "common/types.h" #include "concept.h" +#include "config/config.h" #include "enum.h" +#include #include #include #include @@ -79,6 +81,10 @@ public: template opt_ref find(const std::string &name) const; + template + std::vector> find( + const clanguml::common::string_or_regex &pattern) const; + template opt_ref find(diagram_element::id_t id) const; @@ -217,6 +223,23 @@ opt_ref diagram::find(const std::string &name) const return {}; } +template +std::vector> diagram::find( + const common::string_or_regex &pattern) const +{ + std::vector> result; + + for (const auto &element : element_view::view()) { + const auto full_name = element.get().full_name(false); + + if (pattern == full_name) { + result.emplace_back(element); + } + } + + return result; +} + template opt_ref diagram::find(diagram_element::id_t id) const { diff --git a/src/common/model/diagram_filter.cc b/src/common/model/diagram_filter.cc index 96831ceb..d1c4da9d 100644 --- a/src/common/model/diagram_filter.cc +++ b/src/common/model/diagram_filter.cc @@ -173,7 +173,7 @@ tvl::value_t anyof_filter::match( } namespace_filter::namespace_filter( - filter_t type, std::vector namespaces) + filter_t type, std::vector namespaces) : filter_visitor{type} , namespaces_{std::move(namespaces)} { @@ -192,7 +192,7 @@ tvl::value_t namespace_filter::match( return ns.starts_with(ns_pattern) || ns == ns_pattern; } else { - const auto ®ex = std::get(nsit.value()); + const auto ®ex = std::get(nsit.value()); return regex == ns.to_string(); } }); @@ -226,7 +226,7 @@ tvl::value_t namespace_filter::match( return result; } else { - return std::get(nsit.value()) == + return std::get(nsit.value()) == e.full_name(false); } }); @@ -239,14 +239,14 @@ tvl::value_t namespace_filter::match( std::get(nsit.value())); } else { - return std::get(nsit.value()) == + return std::get(nsit.value()) == e.full_name(false); } }); } element_filter::element_filter( - filter_t type, std::vector elements) + filter_t type, std::vector elements) : filter_visitor{type} , elements_{std::move(elements)} { @@ -312,7 +312,7 @@ tvl::value_t method_type_filter::match( } subclass_filter::subclass_filter( - filter_t type, std::vector roots) + filter_t type, std::vector roots) : filter_visitor{type} , roots_{std::move(roots)} { @@ -361,7 +361,8 @@ tvl::value_t subclass_filter::match(const diagram &d, const element &e) const return false; } -parents_filter::parents_filter(filter_t type, std::vector children) +parents_filter::parents_filter( + filter_t type, std::vector children) : filter_visitor{type} , children_{std::move(children)} { @@ -383,11 +384,13 @@ tvl::value_t parents_filter::match(const diagram &d, const element &e) const // First get all parents of element e clanguml::common::reference_set parents; - for (const auto &child : children_) { - auto child_ref = cd.find(child); - if (!child_ref.has_value()) - continue; - parents.emplace(child_ref.value()); + for (const auto &child_pattern : children_) { + auto child_refs = cd.find(child_pattern); + + for (auto &child : child_refs) { + if (child.has_value()) + parents.emplace(child.value()); + } } cd.get_parents(parents); diff --git a/src/common/model/diagram_filter.h b/src/common/model/diagram_filter.h index a90cb1e5..25e2f998 100644 --- a/src/common/model/diagram_filter.h +++ b/src/common/model/diagram_filter.h @@ -113,7 +113,7 @@ private: struct namespace_filter : public filter_visitor { namespace_filter( - filter_t type, std::vector namespaces); + filter_t type, std::vector namespaces); ~namespace_filter() override = default; @@ -122,19 +122,19 @@ struct namespace_filter : public filter_visitor { tvl::value_t match(const diagram &d, const element &e) const override; private: - std::vector namespaces_; + std::vector namespaces_; }; struct element_filter : public filter_visitor { element_filter( - filter_t type, std::vector elements); + filter_t type, std::vector elements); ~element_filter() override = default; tvl::value_t match(const diagram &d, const element &e) const override; private: - std::vector elements_; + std::vector elements_; }; struct element_type_filter : public filter_visitor { @@ -162,25 +162,25 @@ private: }; struct subclass_filter : public filter_visitor { - subclass_filter(filter_t type, std::vector roots); + subclass_filter(filter_t type, std::vector roots); ~subclass_filter() override = default; tvl::value_t match(const diagram &d, const element &e) const override; private: - std::vector roots_; + std::vector roots_; }; struct parents_filter : public filter_visitor { - parents_filter(filter_t type, std::vector roots); + parents_filter(filter_t type, std::vector roots); ~parents_filter() override = default; tvl::value_t match(const diagram &d, const element &e) const override; private: - std::vector children_; + std::vector children_; }; template + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "types.h" + +namespace clanguml::common { + +std::string to_string(const std::string &s) { return s; } + +std::string to_string(string_or_regex sr) { return sr.to_string(); } + +}; diff --git a/src/common/types.h b/src/common/types.h index 749812f9..4fdb1f15 100644 --- a/src/common/types.h +++ b/src/common/types.h @@ -1,5 +1,5 @@ /** - * src/class_diagram/visitor/translation_unit_visitor.h + * src/common/types.h * * Copyright (c) 2021-2023 Bartek Kryza * @@ -20,15 +20,21 @@ #include #include #include +#include #include +#include #include +#include "model/namespace.h" + namespace clanguml::common { using id_t = int64_t; enum class generator_type_t { plantuml, json }; +std::string to_string(const std::string &s); + template class optional_ref { public: using optional_type = T; @@ -137,4 +143,76 @@ using reference_vector = std::vector>; template using reference_set = std::unordered_set>; +/** + * @brief Wrapper around std::regex, which contains original pattern + */ +struct regex { + regex(std::regex r, std::string p) + : regexp{std::move(r)} + , pattern{std::move(p)} + { + } + + [[nodiscard]] bool operator==(const std::string &v) const + { + return std::regex_match(v, regexp); + } + + std::regex regexp; + std::string pattern; +}; + +template struct or_regex { + or_regex() = default; + + or_regex(T v) + : value_{std::move(v)} + { + } + + or_regex(std::regex r, std::string p) + : value_{regex{std::move(r), std::move(p)}} + { + } + + or_regex &operator=(const T &v) + { + value_ = v; + return *this; + } + + or_regex &operator=(const regex &v) + { + value_ = v; + return *this; + } + + [[nodiscard]] bool operator==(const T &v) const + { + if (std::holds_alternative(value_)) + return std::regex_match(v, std::get(value_).regexp); + + return std::get(value_) == v; + } + + std::string to_string() const + { + if (std::holds_alternative(value_)) + return std::get(value_).pattern; + + return clanguml::common::to_string(std::get(value_)); + } + + const std::variant &value() const { return value_; } + +private: + std::variant value_; +}; + +using string_or_regex = or_regex; + +std::string to_string(string_or_regex sr); + +using namespace_or_regex = common::or_regex; + } // namespace clanguml::common \ No newline at end of file diff --git a/src/config/config.cc b/src/config/config.cc index 44ebafb0..95bd25bd 100644 --- a/src/config/config.cc +++ b/src/config/config.cc @@ -24,8 +24,6 @@ namespace clanguml::config { -std::string to_string(const std::string &s) { return s; } - std::string to_string(const hint_t t) { switch (t) { @@ -87,8 +85,6 @@ std::string to_string(method_type mt) } } -std::string to_string(string_or_regex sr) { return sr.to_string(); } - std::string to_string(const comment_parser_t cp) { switch (cp) { diff --git a/src/config/config.h b/src/config/config.h index 0355fe1e..ee1ec919 100644 --- a/src/config/config.h +++ b/src/config/config.h @@ -19,6 +19,7 @@ #include "class_diagram/model/diagram.h" #include "common/model/enums.h" +#include "common/types.h" #include "option.h" #include "util/util.h" @@ -36,80 +37,6 @@ namespace clanguml { namespace config { -std::string to_string(const std::string &s); - -/** - * @brief Wrapper around std::regex, which contains original pattern - */ -struct regex { - regex(std::regex r, std::string p) - : regexp{std::move(r)} - , pattern{std::move(p)} - { - } - - [[nodiscard]] bool operator==(const std::string &v) const - { - return std::regex_match(v, regexp); - } - - std::regex regexp; - std::string pattern; -}; - -template struct or_regex { - or_regex() = default; - - or_regex(T v) - : value_{std::move(v)} - { - } - - or_regex(std::regex r, std::string p) - : value_{regex{std::move(r), std::move(p)}} - { - } - - or_regex &operator=(const T &v) - { - value_ = v; - return *this; - } - - or_regex &operator=(const regex &v) - { - value_ = v; - return *this; - } - - [[nodiscard]] bool operator==(const T &v) const - { - if (std::holds_alternative(value_)) - return std::regex_match(v, std::get(value_).regexp); - - return std::get(value_) == v; - } - - std::string to_string() const - { - if (std::holds_alternative(value_)) - return std::get(value_).pattern; - - return clanguml::config::to_string(std::get(value_)); - } - - const std::variant &value() const { return value_; } - -private: - std::variant value_; -}; - -using string_or_regex = or_regex; - -std::string to_string(string_or_regex sr); - -using namespace_or_regex = or_regex; - enum class method_arguments { full, abbreviated, none }; enum class method_type { @@ -148,9 +75,9 @@ struct diagram_template { }; struct filter { - std::vector namespaces; + std::vector namespaces; - std::vector elements; + std::vector elements; // E.g.: // - class @@ -170,9 +97,9 @@ struct filter { // - private std::vector access; - std::vector subclasses; + std::vector subclasses; - std::vector parents; + std::vector parents; std::vector specializations; diff --git a/src/config/yaml_decoders.cc b/src/config/yaml_decoders.cc index b6701079..50e22376 100644 --- a/src/config/yaml_decoders.cc +++ b/src/config/yaml_decoders.cc @@ -20,6 +20,8 @@ #include "diagram_templates.h" namespace YAML { +using clanguml::common::namespace_or_regex; +using clanguml::common::string_or_regex; using clanguml::common::model::access_t; using clanguml::common::model::relationship_t; using clanguml::config::class_diagram; @@ -35,14 +37,12 @@ using clanguml::config::location_t; using clanguml::config::member_order_t; using clanguml::config::method_arguments; using clanguml::config::method_type; -using clanguml::config::namespace_or_regex; using clanguml::config::package_diagram; using clanguml::config::package_type_t; using clanguml::config::plantuml; using clanguml::config::relationship_hint_t; using clanguml::config::sequence_diagram; using clanguml::config::source_location; -using clanguml::config::string_or_regex; inline bool has_key(const YAML::Node &n, const std::string &key) { diff --git a/src/config/yaml_emitters.cc b/src/config/yaml_emitters.cc index 20f883c4..c30bf413 100644 --- a/src/config/yaml_emitters.cc +++ b/src/config/yaml_emitters.cc @@ -18,39 +18,7 @@ #include "config.h" -namespace clanguml::common::model { -YAML::Emitter &operator<<(YAML::Emitter &out, const namespace_ &n) -{ - out << n.to_string(); - return out; -} - -YAML::Emitter &operator<<(YAML::Emitter &out, const relationship_t &r) -{ - out << to_string(r); - return out; -} - -YAML::Emitter &operator<<(YAML::Emitter &out, const access_t &a) -{ - out << to_string(a); - return out; -} - -YAML::Emitter &operator<<(YAML::Emitter &out, const diagram_t &d) -{ - out << to_string(d); - return out; -} -} // namespace clanguml::common::model - -namespace clanguml::config { - -YAML::Emitter &operator<<(YAML::Emitter &out, const method_type &m) -{ - out << to_string(m); - return out; -} +namespace clanguml::common { YAML::Emitter &operator<<(YAML::Emitter &out, const string_or_regex &m) { @@ -78,6 +46,42 @@ YAML::Emitter &operator<<(YAML::Emitter &out, const namespace_or_regex &m) return out; } +namespace model { +YAML::Emitter &operator<<(YAML::Emitter &out, const namespace_ &n) +{ + out << n.to_string(); + return out; +} + +YAML::Emitter &operator<<(YAML::Emitter &out, const relationship_t &r) +{ + out << to_string(r); + return out; +} + +YAML::Emitter &operator<<(YAML::Emitter &out, const access_t &a) +{ + out << to_string(a); + return out; +} + +YAML::Emitter &operator<<(YAML::Emitter &out, const diagram_t &d) +{ + out << to_string(d); + return out; +} + +} // namespace model +} // namespace clanguml::common + +namespace clanguml::config { + +YAML::Emitter &operator<<(YAML::Emitter &out, const method_type &m) +{ + out << to_string(m); + return out; +} + YAML::Emitter &operator<<(YAML::Emitter &out, const filter &f) { out << YAML::BeginMap; diff --git a/tests/test_config_data/filters.yml b/tests/test_config_data/filters.yml index 30cb9cad..e46aeec1 100644 --- a/tests/test_config_data/filters.yml +++ b/tests/test_config_data/filters.yml @@ -53,4 +53,9 @@ diagrams: type: class include: subclasses: - - r: 'ns1::ns2::Base[A|B]' \ No newline at end of file + - r: 'ns1::ns2::Base[A|B]' + regex_parents_test: + type: class + include: + parents: + - r: 'ns1::ns2::.+[1|2]' \ No newline at end of file diff --git a/tests/test_filters.cc b/tests/test_filters.cc index 96757606..9d366bcb 100644 --- a/tests/test_filters.cc +++ b/tests/test_filters.cc @@ -312,6 +312,110 @@ TEST_CASE("Test subclasses regexp filter", "[unit-test]") CHECK(!filter.should_include(*c)); } +TEST_CASE("Test parents regexp filter", "[unit-test]") +{ + using clanguml::class_diagram::model::class_method; + using clanguml::class_diagram::model::class_parent; + using clanguml::common::to_id; + using clanguml::common::model::access_t; + using clanguml::common::model::diagram_filter; + using clanguml::common::model::namespace_; + using clanguml::common::model::package; + using clanguml::common::model::source_file; + using namespace std::string_literals; + + using clanguml::class_diagram::model::class_; + + auto cfg = clanguml::config::load("./test_config_data/filters.yml"); + + auto &config = *cfg.diagrams["regex_parents_test"]; + clanguml::class_diagram::model::diagram diagram; + + auto p = std::make_unique(config.using_namespace()); + p->set_namespace({}); + p->set_name("ns1"); + diagram.add({}, std::move(p)); + p = std::make_unique(config.using_namespace()); + p->set_namespace({"ns1"}); + p->set_name("ns2"); + diagram.add(namespace_{"ns1"}, std::move(p)); + + auto c = std::make_unique(config.using_namespace()); + c->set_namespace(namespace_{"ns1::ns2"}); + c->set_name("BaseA"); + c->set_id(to_id("ns1::ns2::BaseA"s)); + diagram.add(namespace_{"ns1::ns2"}, std::move(c)); + + c = std::make_unique(config.using_namespace()); + c->set_namespace(namespace_{"ns1::ns2"}); + c->set_name("A1"); + c->set_id(to_id("ns1::ns2::A1"s)); + c->add_parent({"ns1::ns2::BaseA"}); + diagram.add(namespace_{"ns1::ns2"}, std::move(c)); + + c = std::make_unique(config.using_namespace()); + c->set_namespace(namespace_{"ns1::ns2"}); + c->set_name("A2"); + c->set_id(to_id("ns1::ns2::A2"s)); + c->add_parent({"ns1::ns2::BaseA"}); + diagram.add(namespace_{"ns1::ns2"}, std::move(c)); + + c = std::make_unique(config.using_namespace()); + c->set_namespace(namespace_{"ns1::ns2"}); + c->set_name("BaseB"); + c->set_id(to_id("ns1::ns2::BaseB"s)); + diagram.add(namespace_{"ns1::ns2"}, std::move(c)); + + c = std::make_unique(config.using_namespace()); + c->set_namespace(namespace_{"ns1::ns2"}); + c->set_name("B1"); + c->set_id(to_id("ns1::ns2::B1"s)); + c->add_parent({"ns1::ns2::BaseB"}); + diagram.add(namespace_{"ns1::ns2"}, std::move(c)); + + c = std::make_unique(config.using_namespace()); + c->set_namespace(namespace_{"ns1::ns2"}); + c->set_name("B2"); + c->set_id(to_id("ns1::ns2::B2"s)); + c->add_parent({"ns1::ns2::BaseB"}); + diagram.add(namespace_{"ns1::ns2"}, std::move(c)); + + c = std::make_unique(config.using_namespace()); + c->set_namespace(namespace_{"ns1::ns2"}); + c->set_name("Common"); + c->set_id(to_id("ns1::ns2::Common"s)); + diagram.add(namespace_{"ns1::ns2"}, std::move(c)); + + c = std::make_unique(config.using_namespace()); + c->set_namespace(namespace_{"ns1::ns2"}); + c->set_name("C3"); + c->set_id(to_id("ns1::ns2::C3"s)); + c->add_parent({"ns1::ns2::Common"}); + diagram.add(namespace_{"ns1::ns2"}, std::move(c)); + + diagram.set_complete(true); + + diagram_filter filter(diagram, config); + + c = std::make_unique(config.using_namespace()); + c->set_namespace(namespace_{"ns1::ns2"}); + c->set_name("BaseA"); + c->set_id(to_id("ns1::ns2::BaseA"s)); + CHECK(filter.should_include(*c)); + + c = std::make_unique(config.using_namespace()); + c->set_namespace(namespace_{"ns1::ns2"}); + c->set_name("BaseB"); + c->set_id(to_id("ns1::ns2::BaseB"s)); + CHECK(filter.should_include(*c)); + + c = std::make_unique(config.using_namespace()); + c->set_namespace(namespace_{"ns1::ns2"}); + c->set_name("Common"); + c->set_id(to_id("ns1::ns2::Common"s)); + CHECK(!filter.should_include(*c)); +} + /// /// Main test function /// From b0501d4bfbba8fdcc1f2674787ad7a09d7b7c2c3 Mon Sep 17 00:00:00 2001 From: Bartek Kryza Date: Thu, 8 Jun 2023 14:08:31 +0200 Subject: [PATCH 06/15] Added regex support to specializations filter --- src/common/model/diagram_filter.cc | 22 +++++---- src/common/model/diagram_filter.h | 29 ++++++++---- src/config/config.h | 2 +- tests/test_config_data/filters.yml | 7 ++- tests/test_filters.cc | 74 ++++++++++++++++++++++++++++++ 5 files changed, 114 insertions(+), 20 deletions(-) diff --git a/src/common/model/diagram_filter.cc b/src/common/model/diagram_filter.cc index d1c4da9d..4357751f 100644 --- a/src/common/model/diagram_filter.cc +++ b/src/common/model/diagram_filter.cc @@ -681,8 +681,9 @@ void diagram_filter::init_filters(const config::diagram &c) element_filters.emplace_back(std::make_unique< edge_traversal_filter>(filter_t::kInclusive, - relationship_t::kInstantiation, c.include().specializations)); + class_diagram::model::class_, common::string_or_regex>>( + filter_t::kInclusive, relationship_t::kInstantiation, + c.include().specializations)); element_filters.emplace_back(std::make_unique< edge_traversal_filter>( + element_filters.emplace_back(std::make_unique>( filter_t::kInclusive, relationship_t::kAssociation, dependants)); - element_filters.emplace_back(std::make_unique< - edge_traversal_filter>( + element_filters.emplace_back(std::make_unique>( filter_t::kInclusive, relationship_t::kAssociation, dependencies, true)); } @@ -777,8 +778,9 @@ void diagram_filter::init_filters(const config::diagram &c) add_exclusive_filter(std::make_unique( filter_t::kExclusive, c.exclude().parents)); - add_exclusive_filter(std::make_unique>( + add_exclusive_filter(std::make_unique< + edge_traversal_filter>( filter_t::kExclusive, relationship_t::kInstantiation, c.exclude().specializations)); diff --git a/src/common/model/diagram_filter.h b/src/common/model/diagram_filter.h index 25e2f998..fef070c1 100644 --- a/src/common/model/diagram_filter.h +++ b/src/common/model/diagram_filter.h @@ -184,10 +184,11 @@ private: }; template struct edge_traversal_filter : public filter_visitor { edge_traversal_filter(filter_t type, relationship_t relationship, - std::vector roots, bool forward = false) + std::vector roots, bool forward = false) : filter_visitor{type} , roots_{std::move(roots)} , relationship_{relationship} @@ -199,8 +200,8 @@ struct edge_traversal_filter : public filter_visitor { tvl::value_t match(const diagram &d, const MatchOverrideT &e) const override { - // This filter should only be run on the completely generated diagram - // model by visitor + // This filter should only be run only on diagram models after the + // entire AST has been visited if (!d.complete()) return {}; @@ -285,10 +286,22 @@ private: // First get all elements specified in the filter configuration // which will serve as starting points for the search // of matching elements - for (const auto &template_root : roots_) { - auto template_ref = detail::get(cd, template_root); - if (template_ref.has_value()) { - matching_elements_.emplace(template_ref.value()); + for (const auto &root_pattern : roots_) { + if constexpr (std::is_same_v) { + auto root_refs = cd.template find( + root_pattern); + + for (auto &root : root_refs) { + if (root.has_value()) + matching_elements_.emplace(root.value()); + } + } + else { + auto root_ref = detail::get(cd, root_pattern); + if (root_ref.has_value()) { + matching_elements_.emplace(root_ref.value()); + } } } @@ -318,7 +331,7 @@ private: initialized_ = true; } - std::vector roots_; + std::vector roots_; relationship_t relationship_; mutable bool initialized_{false}; mutable clanguml::common::reference_set matching_elements_; diff --git a/src/config/config.h b/src/config/config.h index ee1ec919..e3a53149 100644 --- a/src/config/config.h +++ b/src/config/config.h @@ -101,7 +101,7 @@ struct filter { std::vector parents; - std::vector specializations; + std::vector specializations; std::vector dependants; diff --git a/tests/test_config_data/filters.yml b/tests/test_config_data/filters.yml index e46aeec1..8fb02e1d 100644 --- a/tests/test_config_data/filters.yml +++ b/tests/test_config_data/filters.yml @@ -58,4 +58,9 @@ diagrams: type: class include: parents: - - r: 'ns1::ns2::.+[1|2]' \ No newline at end of file + - r: 'ns1::ns2::.+[1|2]' + regex_specializations_test: + type: class + include: + specializations: + - r: 'A' \ No newline at end of file diff --git a/tests/test_filters.cc b/tests/test_filters.cc index 9d366bcb..bb47dfe6 100644 --- a/tests/test_filters.cc +++ b/tests/test_filters.cc @@ -416,6 +416,80 @@ TEST_CASE("Test parents regexp filter", "[unit-test]") CHECK(!filter.should_include(*c)); } +TEST_CASE("Test specializations regexp filter", "[unit-test]") +{ + using clanguml::class_diagram::model::class_method; + using clanguml::class_diagram::model::class_parent; + using clanguml::common::to_id; + using clanguml::common::model::access_t; + using clanguml::common::model::diagram_filter; + using clanguml::common::model::namespace_; + using clanguml::common::model::package; + using clanguml::common::model::relationship; + using clanguml::common::model::relationship_t; + using clanguml::common::model::source_file; + using clanguml::common::model::template_parameter; + using namespace std::string_literals; + + using clanguml::class_diagram::model::class_; + + auto cfg = clanguml::config::load("./test_config_data/filters.yml"); + + auto &config = *cfg.diagrams["regex_specializations_test"]; + clanguml::class_diagram::model::diagram diagram; + + const auto template_id = to_id("A"s); + + auto c = std::make_unique(config.using_namespace()); + c->set_name("A"); + c->add_template( + template_parameter::make_template_type("T", std::nullopt, true)); + c->set_id(template_id); + diagram.add(namespace_{}, std::move(c)); + + c = std::make_unique(config.using_namespace()); + c->set_name("A"); + c->add_template(template_parameter::make_argument("double")); + c->set_id(to_id("A"s)); + c->add_relationship( + relationship{relationship_t::kInstantiation, template_id}); + diagram.add(namespace_{}, std::move(c)); + + c = std::make_unique(config.using_namespace()); + c->set_name("A"); + c->add_template(template_parameter::make_argument("int")); + c->set_id(to_id("A"s)); + c->add_relationship( + relationship{relationship_t::kInstantiation, template_id}); + diagram.add(namespace_{}, std::move(c)); + + c = std::make_unique(config.using_namespace()); + c->set_name("A"); + c->add_template(template_parameter::make_argument("int")); + c->add_template(template_parameter::make_argument("std::string")); + c->set_id(to_id("A"s)); + c->add_relationship( + relationship{relationship_t::kInstantiation, template_id}); + diagram.add(namespace_{}, std::move(c)); + + diagram.set_complete(true); + + diagram_filter filter(diagram, config); + + c = std::make_unique(config.using_namespace()); + c->set_name("A"); + c->add_template(template_parameter::make_argument("int")); + c->add_template(template_parameter::make_argument("std::string")); + c->set_id(to_id("A"s)); + CHECK(filter.should_include(*c)); + + c = std::make_unique(config.using_namespace()); + c->set_name("A"); + c->add_template(template_parameter::make_argument("double")); + c->set_id(to_id("A"s)); + CHECK(!filter.should_include(*c)); +} + /// /// Main test function /// From 658bceee4b50af1efe5cf6d7ec475e17559fe46f Mon Sep 17 00:00:00 2001 From: Bartek Kryza Date: Thu, 8 Jun 2023 18:55:10 +0200 Subject: [PATCH 07/15] Added regex support to context filter --- src/common/model/diagram_filter.cc | 75 ++++++++-------- src/common/model/diagram_filter.h | 4 +- src/common/types.h | 12 +++ src/config/config.h | 2 +- tests/test_config_data/filters.yml | 7 +- tests/test_filters.cc | 137 ++++++++++++++++++++--------- 6 files changed, 154 insertions(+), 83 deletions(-) diff --git a/src/common/model/diagram_filter.cc b/src/common/model/diagram_filter.cc index 4357751f..f747dad0 100644 --- a/src/common/model/diagram_filter.cc +++ b/src/common/model/diagram_filter.cc @@ -430,7 +430,8 @@ tvl::value_t access_filter::match( [&a](const auto &access) { return a == access; }); } -context_filter::context_filter(filter_t type, std::vector context) +context_filter::context_filter( + filter_t type, std::vector context) : filter_visitor{type} , context_{std::move(context)} { @@ -447,48 +448,50 @@ tvl::value_t context_filter::match(const diagram &d, const element &e) const return {}; return tvl::any_of(context_.begin(), context_.end(), - [&e, &d](const auto &context_root_name) { - const auto &context_root = + [&e, &d](const auto &context_root_pattern) { + const auto &context_roots = static_cast(d) - .find(context_root_name); + .find(context_root_pattern); - if (context_root.has_value()) { - // This is a direct match to the context root - if (context_root.value().id() == e.id()) - return true; + for (auto &context_root : context_roots) { + if (context_root.has_value()) { + // This is a direct match to the context root + if (context_root.value().id() == e.id()) + return true; - // Return a positive match if the element e is in a direct - // relationship with any of the context_root's - for (const relationship &rel : - context_root.value().relationships()) { - if (d.should_include(rel.type()) && - rel.destination() == e.id()) - return true; - } - for (const relationship &rel : e.relationships()) { - if (d.should_include(rel.type()) && - rel.destination() == context_root.value().id()) - return true; - } - - // Return a positive match if the context_root is a parent - // of the element - for (const class_diagram::model::class_parent &p : - context_root.value().parents()) { - if (p.name() == e.full_name(false)) - return true; - } - if (dynamic_cast(&e) != - nullptr) { - for (const class_diagram::model::class_parent &p : - static_cast(e) - .parents()) { - if (p.name() == context_root.value().full_name(false)) + // Return a positive match if the element e is in a direct + // relationship with any of the context_root's + for (const relationship &rel : + context_root.value().relationships()) { + if (d.should_include(rel.type()) && + rel.destination() == e.id()) return true; } + for (const relationship &rel : e.relationships()) { + if (d.should_include(rel.type()) && + rel.destination() == context_root.value().id()) + return true; + } + + // Return a positive match if the context_root is a parent + // of the element + for (const class_diagram::model::class_parent &p : + context_root.value().parents()) { + if (p.name() == e.full_name(false)) + return true; + } + if (dynamic_cast( + &e) != nullptr) { + for (const class_diagram::model::class_parent &p : + static_cast(e) + .parents()) { + if (p.name() == + context_root.value().full_name(false)) + return true; + } + } } } - return false; }); } diff --git a/src/common/model/diagram_filter.h b/src/common/model/diagram_filter.h index fef070c1..67831ca6 100644 --- a/src/common/model/diagram_filter.h +++ b/src/common/model/diagram_filter.h @@ -363,14 +363,14 @@ private: }; struct context_filter : public filter_visitor { - context_filter(filter_t type, std::vector context); + context_filter(filter_t type, std::vector context); ~context_filter() override = default; tvl::value_t match(const diagram &d, const element &r) const override; private: - std::vector context_; + std::vector context_; }; struct paths_filter : public filter_visitor { diff --git a/src/common/types.h b/src/common/types.h index 4fdb1f15..23deba57 100644 --- a/src/common/types.h +++ b/src/common/types.h @@ -127,6 +127,18 @@ public: return *value_; } + T &operator*() + { + assert(value_ != nullptr); + return *value_; + } + + const T &operator*() const + { + assert(value_ != nullptr); + return *value_; + } + void reset() { value_ = nullptr; } T *get() const { return value_; } diff --git a/src/config/config.h b/src/config/config.h index e3a53149..f4829633 100644 --- a/src/config/config.h +++ b/src/config/config.h @@ -107,7 +107,7 @@ struct filter { std::vector dependencies; - std::vector context; + std::vector context; std::vector paths; diff --git a/tests/test_config_data/filters.yml b/tests/test_config_data/filters.yml index 8fb02e1d..118d48a9 100644 --- a/tests/test_config_data/filters.yml +++ b/tests/test_config_data/filters.yml @@ -63,4 +63,9 @@ diagrams: type: class include: specializations: - - r: 'A' \ No newline at end of file + - r: 'A' + regex_context_test: + type: class + include: + context: + - r: '[A|B]' \ No newline at end of file diff --git a/tests/test_filters.cc b/tests/test_filters.cc index bb47dfe6..ded1bcc7 100644 --- a/tests/test_filters.cc +++ b/tests/test_filters.cc @@ -293,23 +293,9 @@ TEST_CASE("Test subclasses regexp filter", "[unit-test]") diagram_filter filter(diagram, config); - c = std::make_unique(config.using_namespace()); - c->set_namespace(namespace_{"ns1::ns2"}); - c->set_name("A1"); - c->set_id(to_id("ns1::ns2::A1"s)); - CHECK(filter.should_include(*c)); - - c = std::make_unique(config.using_namespace()); - c->set_namespace(namespace_{"ns1::ns2"}); - c->set_name("B1"); - c->set_id(to_id("ns1::ns2::B1"s)); - CHECK(filter.should_include(*c)); - - c = std::make_unique(config.using_namespace()); - c->set_namespace(namespace_{"ns1::ns2"}); - c->set_name("C1"); - c->set_id(to_id("ns1::ns2::C1"s)); - CHECK(!filter.should_include(*c)); + CHECK(filter.should_include(*diagram.find("ns1::ns2::A1"))); + CHECK(filter.should_include(*diagram.find("ns1::ns2::B1"))); + CHECK(!filter.should_include(*diagram.find("ns1::ns2::C1"))); } TEST_CASE("Test parents regexp filter", "[unit-test]") @@ -397,23 +383,9 @@ TEST_CASE("Test parents regexp filter", "[unit-test]") diagram_filter filter(diagram, config); - c = std::make_unique(config.using_namespace()); - c->set_namespace(namespace_{"ns1::ns2"}); - c->set_name("BaseA"); - c->set_id(to_id("ns1::ns2::BaseA"s)); - CHECK(filter.should_include(*c)); - - c = std::make_unique(config.using_namespace()); - c->set_namespace(namespace_{"ns1::ns2"}); - c->set_name("BaseB"); - c->set_id(to_id("ns1::ns2::BaseB"s)); - CHECK(filter.should_include(*c)); - - c = std::make_unique(config.using_namespace()); - c->set_namespace(namespace_{"ns1::ns2"}); - c->set_name("Common"); - c->set_id(to_id("ns1::ns2::Common"s)); - CHECK(!filter.should_include(*c)); + CHECK(filter.should_include(*diagram.find("ns1::ns2::BaseA"))); + CHECK(filter.should_include(*diagram.find("ns1::ns2::BaseB"))); + CHECK(!filter.should_include(*diagram.find("ns1::ns2::Common"))); } TEST_CASE("Test specializations regexp filter", "[unit-test]") @@ -476,18 +448,97 @@ TEST_CASE("Test specializations regexp filter", "[unit-test]") diagram_filter filter(diagram, config); - c = std::make_unique(config.using_namespace()); + CHECK(filter.should_include(*diagram.find("A"))); + CHECK(!filter.should_include(*diagram.find("A"))); +} + +TEST_CASE("Test context regexp filter", "[unit-test]") +{ + using clanguml::class_diagram::model::class_; + using clanguml::class_diagram::model::class_method; + using clanguml::class_diagram::model::class_parent; + using clanguml::common::to_id; + using clanguml::common::model::access_t; + using clanguml::common::model::diagram_filter; + using clanguml::common::model::namespace_; + using clanguml::common::model::package; + using clanguml::common::model::relationship; + using clanguml::common::model::relationship_t; + using clanguml::common::model::source_file; + using clanguml::common::model::template_parameter; + using namespace std::string_literals; + + using clanguml::class_diagram::model::class_; + + auto cfg = clanguml::config::load("./test_config_data/filters.yml"); + + auto &config = *cfg.diagrams["regex_context_test"]; + clanguml::class_diagram::model::diagram diagram; + + auto c = std::make_unique(config.using_namespace()); c->set_name("A"); - c->add_template(template_parameter::make_argument("int")); - c->add_template(template_parameter::make_argument("std::string")); - c->set_id(to_id("A"s)); - CHECK(filter.should_include(*c)); + c->set_id(to_id("A"s)); + diagram.add(namespace_{}, std::move(c)); c = std::make_unique(config.using_namespace()); - c->set_name("A"); - c->add_template(template_parameter::make_argument("double")); - c->set_id(to_id("A"s)); - CHECK(!filter.should_include(*c)); + c->set_name("A1"); + c->set_id(to_id("A1"s)); + c->add_relationship( + relationship{relationship_t::kAssociation, to_id("A"s)}); + diagram.add(namespace_{}, std::move(c)); + + c = std::make_unique(config.using_namespace()); + c->set_name("A2"); + c->set_id(to_id("A2"s)); + c->add_relationship(relationship{relationship_t::kDependency, to_id("A"s)}); + diagram.add(namespace_{}, std::move(c)); + + c = std::make_unique(config.using_namespace()); + c->set_name("A21"); + c->set_id(to_id("A21"s)); + c->add_relationship( + relationship{relationship_t::kDependency, to_id("A2"s)}); + diagram.add(namespace_{}, std::move(c)); + + c = std::make_unique(config.using_namespace()); + c->set_name("B"); + c->set_id(to_id("B"s)); + diagram.add(namespace_{}, std::move(c)); + + c = std::make_unique(config.using_namespace()); + c->set_name("B1"); + c->set_id(to_id("B1"s)); + c->add_relationship( + relationship{relationship_t::kAssociation, to_id("B"s)}); + diagram.add(namespace_{}, std::move(c)); + + c = std::make_unique(config.using_namespace()); + c->set_name("C"); + c->set_id(to_id("C"s)); + diagram.add(namespace_{}, std::move(c)); + + c = std::make_unique(config.using_namespace()); + c->set_name("C1"); + c->set_id(to_id("C1"s)); + c->add_relationship( + relationship{relationship_t::kAssociation, to_id("C"s)}); + diagram.add(namespace_{}, std::move(c)); + + diagram.set_complete(true); + + diagram_filter filter(diagram, config); + + CHECK(filter.should_include(*diagram.find("A"))); + CHECK(filter.should_include(*diagram.find("A1"))); + CHECK(filter.should_include(*diagram.find("A2"))); + + CHECK(!filter.should_include(*diagram.find("A21"))); + + CHECK(filter.should_include(*diagram.find("B"))); + CHECK(filter.should_include(*diagram.find("B1"))); + + CHECK(!filter.should_include(*diagram.find("C"))); + CHECK(!filter.should_include(*diagram.find("C1"))); } /// From 7e416ffa97424d9d0b76df1896cf0188fc2fecde Mon Sep 17 00:00:00 2001 From: Bartek Kryza Date: Fri, 9 Jun 2023 00:44:01 +0200 Subject: [PATCH 08/15] Added regex support to dependencies and dependants filter --- src/common/model/diagram_filter.cc | 126 +++++++++++---------- src/common/model/diagram_filter.h | 3 +- src/common/types.h | 8 ++ src/config/config.h | 4 +- src/package_diagram/model/diagram.h | 21 ++++ tests/test_config_data/filters.yml | 12 +- tests/test_filters.cc | 168 ++++++++++++++++++++++++++++ 7 files changed, 281 insertions(+), 61 deletions(-) diff --git a/src/common/model/diagram_filter.cc b/src/common/model/diagram_filter.cc index f747dad0..d4364fc6 100644 --- a/src/common/model/diagram_filter.cc +++ b/src/common/model/diagram_filter.cc @@ -640,6 +640,29 @@ bool diagram_filter::should_include( void diagram_filter::init_filters(const config::diagram &c) { + using specializations_filter_t = + edge_traversal_filter; + + using class_dependants_filter_t = + edge_traversal_filter; + using class_dependencies_filter_t = + edge_traversal_filter; + + using package_dependants_filter_t = + edge_traversal_filter; + using package_dependencies_filter_t = + edge_traversal_filter; + + using source_file_dependency_filter_t = + edge_traversal_filter; + // Process inclusive filters if (c.include) { add_inclusive_filter(std::make_unique( @@ -682,58 +705,55 @@ void diagram_filter::init_filters(const config::diagram &c) element_filters.emplace_back(std::make_unique( filter_t::kInclusive, c.include().parents)); - element_filters.emplace_back(std::make_unique< - edge_traversal_filter>( - filter_t::kInclusive, relationship_t::kInstantiation, - c.include().specializations)); + element_filters.emplace_back( + std::make_unique(filter_t::kInclusive, + relationship_t::kInstantiation, + c.include().specializations)); - element_filters.emplace_back(std::make_unique< - edge_traversal_filter>(filter_t::kInclusive, - relationship_t::kDependency, c.include().dependants)); + element_filters.emplace_back( + std::make_unique( + filter_t::kInclusive, relationship_t::kDependency, + c.include().dependants)); - element_filters.emplace_back(std::make_unique< - edge_traversal_filter>(filter_t::kInclusive, - relationship_t::kDependency, c.include().dependencies, true)); + element_filters.emplace_back( + std::make_unique( + filter_t::kInclusive, relationship_t::kDependency, + c.include().dependencies, true)); } else if (c.type() == diagram_t::kPackage) { - element_filters.emplace_back(std::make_unique>( - filter_t::kInclusive, relationship_t::kDependency, - c.include().dependants)); + element_filters.emplace_back( + std::make_unique( + filter_t::kInclusive, relationship_t::kDependency, + c.include().dependants)); - element_filters.emplace_back(std::make_unique>( - filter_t::kInclusive, relationship_t::kDependency, - c.include().dependencies, true)); + element_filters.emplace_back( + std::make_unique( + filter_t::kInclusive, relationship_t::kDependency, + c.include().dependencies, true)); } else if (c.type() == diagram_t::kInclude) { std::vector dependants; std::vector dependencies; for (auto &&path : c.include().dependants) { - const std::filesystem::path dep_path{path}; + const std::filesystem::path dep_path{*path.get()}; dependants.emplace_back(dep_path.lexically_normal().string()); } for (auto &&path : c.include().dependencies) { - const std::filesystem::path dep_path{path}; + const std::filesystem::path dep_path{*path.get()}; dependencies.emplace_back(dep_path.lexically_normal().string()); } - element_filters.emplace_back(std::make_unique>( - filter_t::kInclusive, relationship_t::kAssociation, - dependants)); + element_filters.emplace_back( + std::make_unique( + filter_t::kInclusive, relationship_t::kAssociation, + dependants)); - element_filters.emplace_back(std::make_unique>( - filter_t::kInclusive, relationship_t::kAssociation, - dependencies, true)); + element_filters.emplace_back( + std::make_unique( + filter_t::kInclusive, relationship_t::kAssociation, + dependencies, true)); } element_filters.emplace_back(std::make_unique( @@ -781,29 +801,23 @@ void diagram_filter::init_filters(const config::diagram &c) add_exclusive_filter(std::make_unique( filter_t::kExclusive, c.exclude().parents)); - add_exclusive_filter(std::make_unique< - edge_traversal_filter>( - filter_t::kExclusive, relationship_t::kInstantiation, - c.exclude().specializations)); + add_exclusive_filter( + std::make_unique(filter_t::kExclusive, + relationship_t::kInstantiation, c.exclude().specializations)); - add_exclusive_filter(std::make_unique>( - filter_t::kExclusive, relationship_t::kDependency, - c.exclude().dependants)); + add_exclusive_filter( + std::make_unique(filter_t::kExclusive, + relationship_t::kDependency, c.exclude().dependants)); - add_exclusive_filter(std::make_unique>( - filter_t::kExclusive, relationship_t::kDependency, - c.exclude().dependants)); + add_exclusive_filter( + std::make_unique(filter_t::kExclusive, + relationship_t::kDependency, c.exclude().dependants)); - add_exclusive_filter(std::make_unique>( - filter_t::kExclusive, relationship_t::kDependency, - c.exclude().dependencies, true)); + add_exclusive_filter( + std::make_unique(filter_t::kExclusive, + relationship_t::kDependency, c.exclude().dependencies, true)); - add_exclusive_filter(std::make_unique>( + add_exclusive_filter(std::make_unique( filter_t::kExclusive, relationship_t::kDependency, c.exclude().dependencies, true)); @@ -812,9 +826,9 @@ void diagram_filter::init_filters(const config::diagram &c) std::vector dependencies; for (auto &&path : c.exclude().dependants) { - std::filesystem::path dep_path{path}; + std::filesystem::path dep_path{*path.get()}; if (dep_path.is_relative()) { - dep_path = c.base_directory() / path; + dep_path = c.base_directory() / *path.get(); dep_path = relative(dep_path, c.relative_to()); } @@ -822,9 +836,9 @@ void diagram_filter::init_filters(const config::diagram &c) } for (auto &&path : c.exclude().dependencies) { - std::filesystem::path dep_path{path}; + std::filesystem::path dep_path{*path.get()}; if (dep_path.is_relative()) { - dep_path = c.base_directory() / path; + dep_path = c.base_directory() / *path.get(); dep_path = relative(dep_path, c.relative_to()); } diff --git a/src/common/model/diagram_filter.h b/src/common/model/diagram_filter.h index 67831ca6..597514f0 100644 --- a/src/common/model/diagram_filter.h +++ b/src/common/model/diagram_filter.h @@ -289,8 +289,7 @@ private: for (const auto &root_pattern : roots_) { if constexpr (std::is_same_v) { - auto root_refs = cd.template find( - root_pattern); + auto root_refs = cd.template find(root_pattern); for (auto &root : root_refs) { if (root.has_value()) diff --git a/src/common/types.h b/src/common/types.h index 23deba57..be383242 100644 --- a/src/common/types.h +++ b/src/common/types.h @@ -207,6 +207,14 @@ template struct or_regex { return std::get(value_) == v; } + template std::optional get() const + { + if (!std::holds_alternative(value_)) + return std::nullopt; + + return std::get(value_); + } + std::string to_string() const { if (std::holds_alternative(value_)) diff --git a/src/config/config.h b/src/config/config.h index f4829633..49130c65 100644 --- a/src/config/config.h +++ b/src/config/config.h @@ -103,9 +103,9 @@ struct filter { std::vector specializations; - std::vector dependants; + std::vector dependants; - std::vector dependencies; + std::vector dependencies; std::vector context; diff --git a/src/package_diagram/model/diagram.h b/src/package_diagram/model/diagram.h index 1a4aadd2..9f64ddb3 100644 --- a/src/package_diagram/model/diagram.h +++ b/src/package_diagram/model/diagram.h @@ -58,6 +58,10 @@ public: template opt_ref find(diagram_element::id_t id) const; + template + std::vector> find( + const clanguml::common::string_or_regex &pattern) const; + template bool add(const path &parent_path, std::unique_ptr &&e) { @@ -106,6 +110,23 @@ opt_ref diagram::find(diagram_element::id_t id) const return {}; } +template +std::vector> diagram::find( + const common::string_or_regex &pattern) const +{ + std::vector> result; + + for (const auto &element : element_view::view()) { + const auto full_name = element.get().full_name(false); + + if (pattern == full_name) { + result.emplace_back(element); + } + } + + return result; +} + template bool diagram::add_with_namespace_path(std::unique_ptr &&p) { diff --git a/tests/test_config_data/filters.yml b/tests/test_config_data/filters.yml index 118d48a9..6d605c24 100644 --- a/tests/test_config_data/filters.yml +++ b/tests/test_config_data/filters.yml @@ -68,4 +68,14 @@ diagrams: type: class include: context: - - r: '[A|B]' \ No newline at end of file + - r: '[A|B]' + regex_dependencies_test: + type: class + include: + dependencies: + - r: 'A21|B1' + regex_dependants_test: + type: class + include: + dependants: + - r: 'A|B' \ No newline at end of file diff --git a/tests/test_filters.cc b/tests/test_filters.cc index ded1bcc7..c1b9869e 100644 --- a/tests/test_filters.cc +++ b/tests/test_filters.cc @@ -541,6 +541,174 @@ TEST_CASE("Test context regexp filter", "[unit-test]") CHECK(!filter.should_include(*diagram.find("C1"))); } +TEST_CASE("Test dependencies regexp filter", "[unit-test]") +{ + using clanguml::class_diagram::model::class_; + using clanguml::class_diagram::model::class_method; + using clanguml::class_diagram::model::class_parent; + using clanguml::common::to_id; + using clanguml::common::model::access_t; + using clanguml::common::model::diagram_filter; + using clanguml::common::model::namespace_; + using clanguml::common::model::package; + using clanguml::common::model::relationship; + using clanguml::common::model::relationship_t; + using clanguml::common::model::source_file; + using clanguml::common::model::template_parameter; + using namespace std::string_literals; + using clanguml::class_diagram::model::class_; + + auto cfg = clanguml::config::load("./test_config_data/filters.yml"); + + auto &config = *cfg.diagrams["regex_dependencies_test"]; + clanguml::class_diagram::model::diagram diagram; + + auto c = std::make_unique(config.using_namespace()); + c->set_name("A"); + c->set_id(to_id("A"s)); + diagram.add(namespace_{}, std::move(c)); + + c = std::make_unique(config.using_namespace()); + c->set_name("A1"); + c->set_id(to_id("A1"s)); + c->add_relationship(relationship{relationship_t::kDependency, to_id("A"s)}); + diagram.add(namespace_{}, std::move(c)); + + c = std::make_unique(config.using_namespace()); + c->set_name("A2"); + c->set_id(to_id("A2"s)); + c->add_relationship(relationship{relationship_t::kDependency, to_id("A"s)}); + diagram.add(namespace_{}, std::move(c)); + + c = std::make_unique(config.using_namespace()); + c->set_name("A21"); + c->set_id(to_id("A21"s)); + c->add_relationship( + relationship{relationship_t::kDependency, to_id("A2"s)}); + diagram.add(namespace_{}, std::move(c)); + + c = std::make_unique(config.using_namespace()); + c->set_name("B"); + c->set_id(to_id("B"s)); + diagram.add(namespace_{}, std::move(c)); + + c = std::make_unique(config.using_namespace()); + c->set_name("B1"); + c->set_id(to_id("B1"s)); + c->add_relationship(relationship{relationship_t::kDependency, to_id("B"s)}); + diagram.add(namespace_{}, std::move(c)); + + c = std::make_unique(config.using_namespace()); + c->set_name("C"); + c->set_id(to_id("C"s)); + diagram.add(namespace_{}, std::move(c)); + + c = std::make_unique(config.using_namespace()); + c->set_name("C1"); + c->set_id(to_id("C1"s)); + c->add_relationship(relationship{relationship_t::kDependency, to_id("C"s)}); + diagram.add(namespace_{}, std::move(c)); + + diagram.set_complete(true); + + diagram_filter filter(diagram, config); + + CHECK(filter.should_include(*diagram.find("A"))); + CHECK(!filter.should_include(*diagram.find("A1"))); + CHECK(filter.should_include(*diagram.find("A2"))); + CHECK(filter.should_include(*diagram.find("A21"))); + + CHECK(filter.should_include(*diagram.find("B"))); + CHECK(filter.should_include(*diagram.find("B1"))); + + CHECK(!filter.should_include(*diagram.find("C"))); + CHECK(!filter.should_include(*diagram.find("C1"))); +} + +TEST_CASE("Test dependants regexp filter", "[unit-test]") +{ + using clanguml::class_diagram::model::class_; + using clanguml::class_diagram::model::class_method; + using clanguml::class_diagram::model::class_parent; + using clanguml::common::to_id; + using clanguml::common::model::access_t; + using clanguml::common::model::diagram_filter; + using clanguml::common::model::namespace_; + using clanguml::common::model::package; + using clanguml::common::model::relationship; + using clanguml::common::model::relationship_t; + using clanguml::common::model::source_file; + using clanguml::common::model::template_parameter; + using namespace std::string_literals; + using clanguml::class_diagram::model::class_; + + auto cfg = clanguml::config::load("./test_config_data/filters.yml"); + + auto &config = *cfg.diagrams["regex_dependants_test"]; + clanguml::class_diagram::model::diagram diagram; + + auto c = std::make_unique(config.using_namespace()); + c->set_name("A"); + c->set_id(to_id("A"s)); + diagram.add(namespace_{}, std::move(c)); + + c = std::make_unique(config.using_namespace()); + c->set_name("A1"); + c->set_id(to_id("A1"s)); + c->add_relationship(relationship{relationship_t::kDependency, to_id("A"s)}); + diagram.add(namespace_{}, std::move(c)); + + c = std::make_unique(config.using_namespace()); + c->set_name("A2"); + c->set_id(to_id("A2"s)); + c->add_relationship(relationship{relationship_t::kDependency, to_id("A"s)}); + diagram.add(namespace_{}, std::move(c)); + + c = std::make_unique(config.using_namespace()); + c->set_name("A21"); + c->set_id(to_id("A21"s)); + c->add_relationship( + relationship{relationship_t::kDependency, to_id("A2"s)}); + diagram.add(namespace_{}, std::move(c)); + + c = std::make_unique(config.using_namespace()); + c->set_name("B"); + c->set_id(to_id("B"s)); + diagram.add(namespace_{}, std::move(c)); + + c = std::make_unique(config.using_namespace()); + c->set_name("B1"); + c->set_id(to_id("B1"s)); + c->add_relationship(relationship{relationship_t::kDependency, to_id("B"s)}); + diagram.add(namespace_{}, std::move(c)); + + c = std::make_unique(config.using_namespace()); + c->set_name("C"); + c->set_id(to_id("C"s)); + diagram.add(namespace_{}, std::move(c)); + + c = std::make_unique(config.using_namespace()); + c->set_name("C1"); + c->set_id(to_id("C1"s)); + c->add_relationship(relationship{relationship_t::kDependency, to_id("C"s)}); + diagram.add(namespace_{}, std::move(c)); + + diagram.set_complete(true); + + diagram_filter filter(diagram, config); + + CHECK(filter.should_include(*diagram.find("A"))); + CHECK(filter.should_include(*diagram.find("A1"))); + CHECK(filter.should_include(*diagram.find("A2"))); + CHECK(filter.should_include(*diagram.find("A21"))); + + CHECK(filter.should_include(*diagram.find("B"))); + CHECK(filter.should_include(*diagram.find("B1"))); + + CHECK(!filter.should_include(*diagram.find("C"))); + CHECK(!filter.should_include(*diagram.find("C1"))); +} + /// /// Main test function /// From 0a4e2c88553756f82576f888845bdc3768fbaf70 Mon Sep 17 00:00:00 2001 From: Bartek Kryza Date: Fri, 9 Jun 2023 01:07:49 +0200 Subject: [PATCH 09/15] Fixed clang-tidy warnings --- src/common/model/diagram_filter.cc | 64 +++++++++++++++++------------- src/common/types.cc | 2 +- src/common/types.h | 2 +- 3 files changed, 38 insertions(+), 30 deletions(-) diff --git a/src/common/model/diagram_filter.cc b/src/common/model/diagram_filter.cc index d4364fc6..8ec25be2 100644 --- a/src/common/model/diagram_filter.cc +++ b/src/common/model/diagram_filter.cc @@ -191,10 +191,9 @@ tvl::value_t namespace_filter::match( const auto &ns_pattern = std::get(nsit.value()); return ns.starts_with(ns_pattern) || ns == ns_pattern; } - else { - const auto ®ex = std::get(nsit.value()); - return regex == ns.to_string(); - } + + const auto ®ex = std::get(nsit.value()); + return regex == ns.to_string(); }); } @@ -225,10 +224,9 @@ tvl::value_t namespace_filter::match( return result; } - else { - return std::get(nsit.value()) == - e.full_name(false); - } + + return std::get(nsit.value()) == + e.full_name(false); }); } @@ -238,10 +236,8 @@ tvl::value_t namespace_filter::match( return e.get_namespace().starts_with( std::get(nsit.value())); } - else { - return std::get(nsit.value()) == - e.full_name(false); - } + + return std::get(nsit.value()) == e.full_name(false); }); } @@ -736,13 +732,19 @@ void diagram_filter::init_filters(const config::diagram &c) std::vector dependencies; for (auto &&path : c.include().dependants) { - const std::filesystem::path dep_path{*path.get()}; - dependants.emplace_back(dep_path.lexically_normal().string()); + if (auto p = path.get(); p.has_value()) { + const std::filesystem::path dep_path{*p}; + dependants.emplace_back( + dep_path.lexically_normal().string()); + } } for (auto &&path : c.include().dependencies) { - const std::filesystem::path dep_path{*path.get()}; - dependencies.emplace_back(dep_path.lexically_normal().string()); + if (auto p = path.get(); p.has_value()) { + const std::filesystem::path dep_path{*p}; + dependencies.emplace_back( + dep_path.lexically_normal().string()); + } } element_filters.emplace_back( @@ -826,23 +828,29 @@ void diagram_filter::init_filters(const config::diagram &c) std::vector dependencies; for (auto &&path : c.exclude().dependants) { - std::filesystem::path dep_path{*path.get()}; - if (dep_path.is_relative()) { - dep_path = c.base_directory() / *path.get(); - dep_path = relative(dep_path, c.relative_to()); - } + if (auto p = path.get(); p.has_value()) { + std::filesystem::path dep_path{*p}; + if (dep_path.is_relative()) { + dep_path = c.base_directory() / *p; + dep_path = relative(dep_path, c.relative_to()); + } - dependants.emplace_back(dep_path.lexically_normal().string()); + dependants.emplace_back( + dep_path.lexically_normal().string()); + } } for (auto &&path : c.exclude().dependencies) { - std::filesystem::path dep_path{*path.get()}; - if (dep_path.is_relative()) { - dep_path = c.base_directory() / *path.get(); - dep_path = relative(dep_path, c.relative_to()); - } + if (auto p = path.get(); p.has_value()) { + std::filesystem::path dep_path{*p}; + if (dep_path.is_relative()) { + dep_path = c.base_directory() / *p; + dep_path = relative(dep_path, c.relative_to()); + } - dependencies.emplace_back(dep_path.lexically_normal().string()); + dependencies.emplace_back( + dep_path.lexically_normal().string()); + } } add_exclusive_filter(std::make_unique< diff --git a/src/common/types.cc b/src/common/types.cc index 3f66a56a..b24abeca 100644 --- a/src/common/types.cc +++ b/src/common/types.cc @@ -22,6 +22,6 @@ namespace clanguml::common { std::string to_string(const std::string &s) { return s; } -std::string to_string(string_or_regex sr) { return sr.to_string(); } +std::string to_string(const string_or_regex &sr) { return sr.to_string(); } }; diff --git a/src/common/types.h b/src/common/types.h index be383242..5a2053b6 100644 --- a/src/common/types.h +++ b/src/common/types.h @@ -231,7 +231,7 @@ private: using string_or_regex = or_regex; -std::string to_string(string_or_regex sr); +std::string to_string(const string_or_regex &sr); using namespace_or_regex = common::or_regex; From ac011274366d406ac9e7e697488ceccf1510b22d Mon Sep 17 00:00:00 2001 From: Bartek Kryza Date: Fri, 9 Jun 2023 21:48:19 +0200 Subject: [PATCH 10/15] Added OS details information in version help message --- src/cli/cli_handler.cc | 6 ++++-- src/main.cc | 14 +++++++------- src/util/util.cc | 26 ++++++++++++++++++++++++++ src/util/util.h | 2 ++ 4 files changed, 39 insertions(+), 9 deletions(-) diff --git a/src/cli/cli_handler.cc b/src/cli/cli_handler.cc index bebb0759..b3d1daac 100644 --- a/src/cli/cli_handler.cc +++ b/src/cli/cli_handler.cc @@ -305,8 +305,10 @@ cli_flow_t cli_handler::handle_post_config_options() cli_flow_t cli_handler::print_version() { - ostr_ << "clang-uml " << clanguml::version::CLANG_UML_VERSION << '\n'; - ostr_ << "Copyright (C) 2021-2023 Bartek Kryza " << '\n'; + ostr_ << "clang-uml " << clanguml::version::CLANG_UML_VERSION << std::endl; + ostr_ << "Copyright (C) 2021-2023 Bartek Kryza " + << std::endl; + ostr_ << util::get_os_name() << std::endl; ostr_ << "Built against LLVM/Clang libraries version: " << LLVM_VERSION_STRING << std::endl; ostr_ << "Using LLVM/Clang libraries version: " diff --git a/src/main.cc b/src/main.cc index c96a9867..45b9cf21 100644 --- a/src/main.cc +++ b/src/main.cc @@ -61,7 +61,7 @@ int main(int argc, const char *argv[]) try { const auto db = - clanguml::common::compilation_database::auto_detect_from_directory( + common::compilation_database::auto_detect_from_directory( cli.config); const auto compilation_database_files = db->getAllFiles(); @@ -73,20 +73,20 @@ int main(int argc, const char *argv[]) // We have to generate the translation units list for each diagram // before scheduling tasks, because std::filesystem::current_path // cannot be trusted with multiple threads - clanguml::common::generators::find_translation_units_for_diagrams( + common::generators::find_translation_units_for_diagrams( cli.diagram_names, cli.config, compilation_database_files, translation_units_map); - clanguml::common::generators::generate_diagrams(cli.diagram_names, - cli.config, cli.effective_output_directory, db, cli.verbose, - cli.thread_count, cli.generators, translation_units_map); + common::generators::generate_diagrams(cli.diagram_names, cli.config, + cli.effective_output_directory, db, cli.verbose, cli.thread_count, + cli.generators, translation_units_map); } - catch (clanguml::common::compilation_database_error &e) { + catch (common::compilation_database_error &e) { LOG_ERROR("Failed to load compilation database from {} due to: {}", cli.config.compilation_database_dir(), e.what()); return 1; } - catch (clanguml::util::query_driver_no_paths &e) { + catch (util::query_driver_no_paths &e) { LOG_ERROR("Quering provided compiler driver {} did not provide any " "paths, please make sure the path is correct and that your " "compiler is GCC-compatible: {}", diff --git a/src/util/util.cc b/src/util/util.cc index f307e6c3..24ce86d7 100644 --- a/src/util/util.cc +++ b/src/util/util.cc @@ -20,6 +20,9 @@ #include #include +#if __has_include() +#include +#endif namespace clanguml::util { @@ -124,6 +127,29 @@ std::string get_git_toplevel_dir() return trim(get_process_output("git rev-parse --show-toplevel")); } +std::string get_os_name() +{ +#ifdef _WIN32 + return "Windows, 32-bit"; +#elif _WIN64 + return "Windows, 64-bit"; +#elif __has_include() + utsname utsn; + uname(&utsn); + return fmt::format("{} {} {}", utsn.sysname, utsn.machine, utsn.release); +#elif __linux__ + return "Linux"; +#elif __APPLE__ || __MACH__ + return "macOS"; +#elif __FreeBSD__ + return "FreeBSD"; +#elif __unix__ || __unix + return "Unix"; +#else + return "Unknown"; +#endif +} + std::string ltrim(const std::string &s) { const size_t start = s.find_first_not_of(WHITESPACE); diff --git a/src/util/util.h b/src/util/util.h index eeafe95d..d35eaa07 100644 --- a/src/util/util.h +++ b/src/util/util.h @@ -76,6 +76,8 @@ std::string get_git_commit(); std::string get_git_toplevel_dir(); +std::string get_os_name(); + /** * @brief Split a string using delimiter * From dc74069dfd5c710849e85ce6c338f1e04b366af4 Mon Sep 17 00:00:00 2001 From: Bartek Kryza Date: Sat, 10 Jun 2023 11:16:26 +0200 Subject: [PATCH 11/15] Added glob pattern support in paths filter --- src/common/model/diagram_filter.cc | 40 +++++++++++++++++++----------- src/common/model/diagram_filter.h | 2 +- src/common/types.h | 2 ++ src/config/config.h | 2 +- src/util/util.cc | 2 +- tests/t00061/.clang-uml | 2 +- tests/test_config_data/filters.yml | 5 ++-- 7 files changed, 35 insertions(+), 20 deletions(-) diff --git a/src/common/model/diagram_filter.cc b/src/common/model/diagram_filter.cc index 8ec25be2..0f7663e2 100644 --- a/src/common/model/diagram_filter.cc +++ b/src/common/model/diagram_filter.cc @@ -22,6 +22,7 @@ #include "class_diagram/model/class.h" #include "common/model/package.h" +#include "glob/glob.hpp" #include "include_diagram/model/diagram.h" #include "package_diagram/model/diagram.h" @@ -493,33 +494,44 @@ tvl::value_t context_filter::match(const diagram &d, const element &e) const } paths_filter::paths_filter(filter_t type, const std::filesystem::path &root, - const std::vector &p) + const std::vector &p) : filter_visitor{type} , root_{root} { for (const auto &path : p) { std::filesystem::path absolute_path; - if (path.string().empty() || path.string() == ".") + if (path.empty() || path == ".") absolute_path = root; - else if (path.is_relative()) + else if (std::filesystem::path{path}.is_relative()) absolute_path = root / path; else absolute_path = path; - try { - absolute_path = absolute(absolute_path); - absolute_path = canonical(absolute_path.lexically_normal()); - } - catch (std::filesystem::filesystem_error &e) { - LOG_WARN("Cannot add non-existent path {} to paths filter", - absolute_path.string()); - continue; + bool match_successful{false}; + for (auto &resolved_glob_path : + glob::glob(absolute_path.string(), true)) { + try { + auto resolved_absolute_path = absolute(resolved_glob_path); + resolved_absolute_path = + canonical(resolved_absolute_path.lexically_normal()); + + resolved_absolute_path.make_preferred(); + + paths_.emplace_back(resolved_absolute_path); + + match_successful = true; + } + catch (std::filesystem::filesystem_error &e) { + LOG_WARN("Cannot add non-existent path {} to paths filter", + absolute_path.string()); + continue; + } } - absolute_path.make_preferred(); - - paths_.emplace_back(std::move(absolute_path)); + if (!match_successful) + LOG_WARN( + "Paths filter pattern '{}' did not match any files...", path); } } diff --git a/src/common/model/diagram_filter.h b/src/common/model/diagram_filter.h index 597514f0..5c3e12f5 100644 --- a/src/common/model/diagram_filter.h +++ b/src/common/model/diagram_filter.h @@ -374,7 +374,7 @@ private: struct paths_filter : public filter_visitor { paths_filter(filter_t type, const std::filesystem::path &root, - const std::vector &p); + const std::vector &p); ~paths_filter() override = default; diff --git a/src/common/types.h b/src/common/types.h index 5a2053b6..f7b4baef 100644 --- a/src/common/types.h +++ b/src/common/types.h @@ -235,4 +235,6 @@ std::string to_string(const string_or_regex &sr); using namespace_or_regex = common::or_regex; +struct path_or_regex : public or_regex { }; + } // namespace clanguml::common \ No newline at end of file diff --git a/src/config/config.h b/src/config/config.h index 49130c65..0ee7267e 100644 --- a/src/config/config.h +++ b/src/config/config.h @@ -109,7 +109,7 @@ struct filter { std::vector context; - std::vector paths; + std::vector paths; std::vector method_types; }; diff --git a/src/util/util.cc b/src/util/util.cc index 24ce86d7..c7759336 100644 --- a/src/util/util.cc +++ b/src/util/util.cc @@ -134,7 +134,7 @@ std::string get_os_name() #elif _WIN64 return "Windows, 64-bit"; #elif __has_include() - utsname utsn; + struct utsname utsn; // NOLINT uname(&utsn); return fmt::format("{} {} {}", utsn.sysname, utsn.machine, utsn.release); #elif __linux__ diff --git a/tests/t00061/.clang-uml b/tests/t00061/.clang-uml index aa1a3ec6..c7c9ca95 100644 --- a/tests/t00061/.clang-uml +++ b/tests/t00061/.clang-uml @@ -10,6 +10,6 @@ diagrams: namespaces: - clanguml::t00061 paths: - - include/t00061_a.h + - include/*_a.h using_namespace: - clanguml::t00061 \ No newline at end of file diff --git a/tests/test_config_data/filters.yml b/tests/test_config_data/filters.yml index 6d605c24..6182ee34 100644 --- a/tests/test_config_data/filters.yml +++ b/tests/test_config_data/filters.yml @@ -10,9 +10,10 @@ diagrams: - src/**/*.h include: paths: - - class_diagram/ + - class_d*/ - common - - util + - util/*.h + - util/*.cc - main.cc exclude: paths: From 7564b6408f0216737c20783fe543ffeffb7db5fb Mon Sep 17 00:00:00 2001 From: Bartek Kryza Date: Sat, 10 Jun 2023 17:30:42 +0200 Subject: [PATCH 12/15] Updated troubleshooting --- CHANGELOG.md | 1 + docs/troubleshooting.md | 44 ++++++++++++++++++++++++++++++++--------- 2 files changed, 36 insertions(+), 9 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 1394dcf8..56472c5d 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,6 @@ # CHANGELOG + * Added regexp support to selected diagram filters (#51, #132) * Added method type diagram filter (#145) * Added default method grouping and sorting in class diagrams (#36) * Improved generation of method attributes (e.g. constexpr, noexcept) (#142) diff --git a/docs/troubleshooting.md b/docs/troubleshooting.md index 26a02931..fb797444 100644 --- a/docs/troubleshooting.md +++ b/docs/troubleshooting.md @@ -11,6 +11,7 @@ * [YAML anchors and aliases are not fully supported](#yaml-anchors-and-aliases-are-not-fully-supported) * [Class diagrams](#class-diagrams) * ["fatal error: 'stddef.h' file not found"](#fatal-error-stddefh-file-not-found) + * [Cannot generate classes for `std` namespace](#cannot-generate-classes-for-std-namespace) * [Sequence diagrams](#sequence-diagrams) * [Generated diagram is empty](#generated-diagram-is-empty) * [Generated diagram contains several empty control blocks or calls which should not be there](#generated-diagram-contains-several-empty-control-blocks-or-calls-which-should-not-be-there) @@ -65,16 +66,16 @@ limit the number of translation units to visit for a given diagram, for instance diagrams: ClassAContextDiagram: type: class - ... + # ... glob: - src/classA.cpp - ... + # ... InterfaceHierarchyDiagram: type: class - ... + # ... glob: - src/interfaces/*.cpp - ... + # ... ``` This should improve the generation times for individual diagrams significantly. @@ -143,7 +144,7 @@ that at least one translation unit (e.g. one `cpp`) exists and it is included in the generated `compile_commands.json` database. However, even if your project is a header only library, first check if the -generate `compile_commands.json` contains any entries - if yes you should be +generated `compile_commands.json` contains any entries - if yes you should be fine - just make sure the `glob` pattern in the configuration file matches any of them. This is due to the fact that most header only projects still have test cases, which are compiled and executed, and which include the headers. @@ -178,9 +179,9 @@ output_directory: output - function: 'main(int,const char**)' diagrams: - main_sequence_diagram: *sequence_diagram_anchor + main_sequence_diagram: *sequence_diagram_anchor # This will work foo_sequence_diagram: - <<: *sequence_diagram_anchor + <<: *sequence_diagram_anchor # This will not work glob: [src/foo.cc] start_from: - function: 'foo(int,float)' @@ -197,7 +198,7 @@ yq 'explode(.)' .clang-uml | clang-uml --config - ## Class diagrams ### "fatal error: 'stddef.h' file not found" -This error means that Clang cannot find some standard headers in the include +This error means that Clang cannot find some standard headers in include paths specified in the `compile_commands.json`. This typically happens on macOS and sometimes on Linux, when the code was compiled with different Clang version than `clang-uml` itself. @@ -251,6 +252,31 @@ $ clang-uml --add-compile-flag -I/opt/my_toolchain/include \ --remove-compile-flag -I/usr/include ... ``` +### Cannot generate classes for `std` namespace +Currently, system headers are skipped automatically by `clang-uml`, due to +too many errors they produce when generating diagrams, especially when trying +to process `GCC`'s or `MSVC`'s system headers by `Clang` - not yet sure why +that is the case. + +Basically it's best to either include only specific namespaces through the +inclusion filters, e.g.: + +```yaml +include: + namespaces: + - myns1::myns12 +``` + +or explicitly exclude `std` namespace: + +```yaml +exclude: + namespaces: + - std +``` + +Hopefully this will be eventually resolved. + ## Sequence diagrams ### Generated diagram is empty @@ -275,7 +301,7 @@ configuration file. ### Generated diagram contains several empty control blocks or calls which should not be there -Currently the filtering of call expressions and purging empty control blocks ( +Currently, the filtering of call expressions and purging empty control blocks ( e.g. loops or conditional statements), within which no interesting calls were included in the diagram is not perfect. In case the regular `namespaces` filter From 01ef3dcbcc62dfdf04b1a2c76468b8c4c4488248 Mon Sep 17 00:00:00 2001 From: Bartek Kryza Date: Sat, 10 Jun 2023 18:59:36 +0200 Subject: [PATCH 13/15] Updated diagram filters docs --- docs/diagram_filters.md | 66 +++++++++++++++++++++++++++++++---------- 1 file changed, 50 insertions(+), 16 deletions(-) diff --git a/docs/diagram_filters.md b/docs/diagram_filters.md index 41ac062a..b42bb74c 100644 --- a/docs/diagram_filters.md +++ b/docs/diagram_filters.md @@ -2,18 +2,18 @@ -* [`namespaces`](#namespaces) -* [`elements`](#elements) +* [`namespaces` _[string or regex]_](#namespaces-_string-or-regex_) +* [`elements` _[string or regex]_](#elements-_string-or-regex_) * [`element_types`](#element_types) -* [`paths`](#paths) -* [`context`](#context) +* [`paths` _[string or glob]_](#paths-_string-or-glob_) +* [`context` _[string or regex]_](#context-_string-or-regex_) * [`relationships`](#relationships) -* [`subclasses`](#subclasses) -* [`parents`](#parents) -* [`specializations`](#specializations) +* [`subclasses` _[string or regex]_](#subclasses-_string-or-regex_) +* [`parents` _[string or regex]_](#parents-_string-or-regex_) +* [`specializations` _[string or regex]_](#specializations-_string-or-regex_) * [`access`](#access) * [`method_types`](#method_types) -* [`dependants` and `dependencies`](#dependants-and-dependencies) +* [`dependants` and `dependencies` _[string or regex]_](#dependants-and-dependencies-_string-or-regex_) @@ -36,13 +36,47 @@ to your diagram configuration: - ns1::ns2::detail ``` +Some filters accept either specified exact values, some support regular +expressions while some except glob patterns. + +For filters which accept regular expressions, the regular expression has to +be provided as a map `re: 'pattern'` due to the fact the pointer (`*`) otherwise +would have to be escaped in situations such as `mycontainer`, so for +instance to specify that the diagram should exclude all classes containing the +word `test` simply add the following filter: + +```yaml +exclude: + elements: + - re: '.*test.*' +``` + +`paths` filter is currently the only filter which accepts `glob` like patterns. + +The following table specifies the values allowed in each filter: + +| Filter name | Possible values | Example values | +|-------------------|----------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------| +| `namespaces` | Qualified name or regex | - `ns1::ns2::ClassA`
- `re: '.\*detail.\*'` | +| `elements` | Qualified name or regex | - `ns1::ns2::ClassA`
- `re: '.\*detail.\*'` | +| `paths` | File or dir path or glob pattern | - `src/dir1`
- `src/dir2/a.cpp`
- `src/dir3/*.cpp` | +| `context` | Qualified name or regex | - `ns1::ns2::ClassA`
- `re: 'ns1::ns2::ClassA.+'` | +| `relationships` | Type of relationship | - `inheritance`
- `composition`
- `aggregation`
- `ownership`
- `association`
- `instantiation`
- `friendship`
- `dependency` | +| `subclasses` | Qualified name or regex | - `ns1::ns2::ClassA`
- `re: 'ns1::ns2::ClassA.+'` | +| `parents` | Qualified name or regex | - `ns1::ns2::ClassA`
- `re: 'ns1::ns2::ClassA.+'` | +| `specializations` | Qualified name or regex | - `ns1::ns2::ClassA`
- `re: 'ns1::ns2::ClassA.+'` | +| `access` | Method or member access scope | - `public`
- `protected`
- `private` | +| `method_types` | Type of class method | - `constructor`
- `destructor`
- `assignment`
- `operator`
- `defaulted`
- `deleted`
- `static` | +| `dependants` | Qualified name or regex | - `ns1::ns2::ClassA`
- `re: 'ns1::ns2::ClassA.+'` | +| `dependencies` | Qualified name or regex | - `ns1::ns2::ClassA`
- `re: 'ns1::ns2::ClassA.+'` | + The following filters are available. -## `namespaces` +## `namespaces` _[string or regex]_ Allows to include or exclude entities from specific namespaces. -## `elements` +## `elements` _[string or regex]_ Allows to directly include or exclude specific entities from the diagrams, for instance to exclude a specific class from an included namespace: @@ -67,7 +101,7 @@ to remove all enums from a diagram add the following: - enum ``` -## `paths` +## `paths` _[string or glob]_ This filter allows to include or exclude from the diagram elements declared in specific files. @@ -87,7 +121,7 @@ diagrams: Currently, this filter does not allow any globbing or wildcards, however paths to directories can be specified. -## `context` +## `context` _[string or regex]_ This filter allows to limit the diagram elements only to classes which are in direct relationship (of any kind) with the specified class: @@ -121,15 +155,15 @@ The following relationships can be used in this filter: * friendship * dependency -## `subclasses` +## `subclasses` _[string or regex]_ This filter allows to include or exclude all subclasses of a given class in the diagram. -## `parents` +## `parents` _[string or regex]_ This filter allows to include or exclude all parents (base classes) of a given class in the diagram. -## `specializations` +## `specializations` _[string or regex]_ This filter allows to include or exclude specializations and instantiations of a specific template from the diagram. @@ -155,7 +189,7 @@ This filter allows to include or exclude various method types from the class dia This filter is independent of the `access` filter, which controls which methods are included based on access scope (e.g. `public`). -## `dependants` and `dependencies` +## `dependants` and `dependencies` _[string or regex]_ These filters allow to specify that only dependants or dependencies of a given class should be included in the diagram. This can be useful for analyzing what classes in your project depend on some other class, which could have impact for From 20fe6b1687ce33e463ec42889046d137b614a036 Mon Sep 17 00:00:00 2001 From: Bartek Kryza Date: Sat, 10 Jun 2023 19:02:06 +0200 Subject: [PATCH 14/15] Updated test cases documentation --- docs/test_cases/t00002.md | 2 +- docs/test_cases/t00002_class.svg | 36 ++--- docs/test_cases/t00003.md | 2 +- docs/test_cases/t00003_class.svg | 46 +++---- docs/test_cases/t00004.md | 2 +- docs/test_cases/t00004_class.svg | 78 +++++------ docs/test_cases/t00005.md | 2 +- docs/test_cases/t00005_class.svg | 110 +++++++-------- docs/test_cases/t00006.md | 2 +- docs/test_cases/t00006_class.svg | 134 +++++++++--------- docs/test_cases/t00007.md | 2 +- docs/test_cases/t00007_class.svg | 30 ++-- docs/test_cases/t00008.md | 2 +- docs/test_cases/t00008_class.svg | 70 +++++----- docs/test_cases/t00009.md | 2 +- docs/test_cases/t00009_class.svg | 38 +++--- docs/test_cases/t00010.md | 2 +- docs/test_cases/t00010_class.svg | 38 +++--- docs/test_cases/t00011.md | 2 +- docs/test_cases/t00011_class.svg | 22 +-- docs/test_cases/t00012.md | 2 +- docs/test_cases/t00012_class.svg | 76 +++++------ docs/test_cases/t00013.md | 2 +- docs/test_cases/t00013_class.svg | 90 ++++++------ docs/test_cases/t00014.md | 2 +- docs/test_cases/t00014_class.svg | 150 ++++++++++---------- docs/test_cases/t00015.md | 2 +- docs/test_cases/t00015_class.svg | 22 +-- docs/test_cases/t00016.md | 2 +- docs/test_cases/t00016_class.svg | 26 ++-- docs/test_cases/t00017.md | 2 +- docs/test_cases/t00017_class.svg | 66 ++++----- docs/test_cases/t00018.md | 2 +- docs/test_cases/t00018_class.svg | 18 +-- docs/test_cases/t00019.md | 2 +- docs/test_cases/t00019_class.svg | 46 +++---- docs/test_cases/t00020.md | 2 +- docs/test_cases/t00020_class.svg | 38 +++--- docs/test_cases/t00021.md | 2 +- docs/test_cases/t00021_class.svg | 30 ++-- docs/test_cases/t00022.md | 2 +- docs/test_cases/t00022_class.svg | 14 +- docs/test_cases/t00023.md | 2 +- docs/test_cases/t00023_class.svg | 26 ++-- docs/test_cases/t00024.md | 2 +- docs/test_cases/t00024_class.svg | 22 +-- docs/test_cases/t00025.md | 2 +- docs/test_cases/t00025_class.svg | 38 +++--- docs/test_cases/t00026.md | 2 +- docs/test_cases/t00026_class.svg | 46 +++---- docs/test_cases/t00027.md | 2 +- docs/test_cases/t00027_class.svg | 70 +++++----- docs/test_cases/t00028.md | 2 +- docs/test_cases/t00028_class.svg | 84 ++++++------ docs/test_cases/t00029.md | 2 +- docs/test_cases/t00029_class.svg | 50 +++---- docs/test_cases/t00030.md | 2 +- docs/test_cases/t00030_class.svg | 46 +++---- docs/test_cases/t00031.md | 2 +- docs/test_cases/t00031_class.svg | 52 +++---- docs/test_cases/t00032.md | 2 +- docs/test_cases/t00032_class.svg | 42 +++--- docs/test_cases/t00033.md | 2 +- docs/test_cases/t00033_class.svg | 54 ++++---- docs/test_cases/t00034.md | 2 +- docs/test_cases/t00034_class.svg | 38 +++--- docs/test_cases/t00035.md | 2 +- docs/test_cases/t00035_class.svg | 22 +-- docs/test_cases/t00036.md | 2 +- docs/test_cases/t00036_class.svg | 40 +++--- docs/test_cases/t00037.md | 2 +- docs/test_cases/t00037_class.svg | 54 ++++---- docs/test_cases/t00038.md | 2 +- docs/test_cases/t00038_class.svg | 54 ++++---- docs/test_cases/t00039.md | 2 +- docs/test_cases/t00039_class.svg | 78 +++++------ docs/test_cases/t00040.md | 2 +- docs/test_cases/t00040_class.svg | 26 ++-- docs/test_cases/t00041.md | 2 +- docs/test_cases/t00041_class.svg | 54 ++++---- docs/test_cases/t00042.md | 2 +- docs/test_cases/t00042_class.svg | 42 +++--- docs/test_cases/t00043.md | 2 +- docs/test_cases/t00043_class.svg | 50 +++---- docs/test_cases/t00044.md | 2 +- docs/test_cases/t00044_class.svg | 38 +++--- docs/test_cases/t00045.md | 2 +- docs/test_cases/t00045_class.svg | 70 +++++----- docs/test_cases/t00046.md | 2 +- docs/test_cases/t00046_class.svg | 62 ++++----- docs/test_cases/t00047.md | 2 +- docs/test_cases/t00047_class.svg | 18 +-- docs/test_cases/t00048.md | 2 +- docs/test_cases/t00048_class.svg | 50 +++---- docs/test_cases/t00049.md | 2 +- docs/test_cases/t00049_class.svg | 38 +++--- docs/test_cases/t00050.md | 2 +- docs/test_cases/t00050_class.svg | 70 +++++----- docs/test_cases/t00051.md | 2 +- docs/test_cases/t00051_class.svg | 38 +++--- docs/test_cases/t00052.md | 2 +- docs/test_cases/t00052_class.svg | 38 +++--- docs/test_cases/t00053.md | 2 +- docs/test_cases/t00053_class.svg | 70 +++++----- docs/test_cases/t00054.md | 2 +- docs/test_cases/t00054_class.svg | 78 +++++------ docs/test_cases/t00055.md | 2 +- docs/test_cases/t00055_class.svg | 42 +++--- docs/test_cases/t00056.md | 2 +- docs/test_cases/t00056_class.svg | 94 ++++++------- docs/test_cases/t00057.md | 2 +- docs/test_cases/t00057_class.svg | 126 ++++++++--------- docs/test_cases/t00058.md | 2 +- docs/test_cases/t00058_class.svg | 54 ++++---- docs/test_cases/t00059.md | 2 +- docs/test_cases/t00059_class.svg | 54 ++++---- docs/test_cases/t00060.md | 2 +- docs/test_cases/t00060_class.svg | 38 +++--- docs/test_cases/t00061.md | 4 +- docs/test_cases/t00061_class.svg | 6 +- docs/test_cases/t00062.md | 2 +- docs/test_cases/t00062_class.svg | 198 +++++++++++++-------------- docs/test_cases/t00063.md | 2 +- docs/test_cases/t00063_class.svg | 6 +- docs/test_cases/t00064.md | 2 +- docs/test_cases/t00064_class.svg | 106 +++++++-------- docs/test_cases/t00065.md | 2 +- docs/test_cases/t00065_class.svg | 94 ++++++------- docs/test_cases/t00066.md | 2 +- docs/test_cases/t00066_class.svg | 46 +++---- docs/test_cases/t00067.md | 2 +- docs/test_cases/t00067_class.svg | 46 +++---- docs/test_cases/t20001.md | 2 +- docs/test_cases/t20001_sequence.svg | 62 ++++----- docs/test_cases/t20002.md | 2 +- docs/test_cases/t20002_sequence.svg | 48 +++---- docs/test_cases/t20003.md | 2 +- docs/test_cases/t20003_sequence.svg | 48 +++---- docs/test_cases/t20004.md | 2 +- docs/test_cases/t20004_sequence.svg | 120 ++++++++-------- docs/test_cases/t20005.md | 2 +- docs/test_cases/t20005_sequence.svg | 36 ++--- docs/test_cases/t20006.md | 2 +- docs/test_cases/t20006_sequence.svg | 150 ++++++++++---------- docs/test_cases/t20007.md | 2 +- docs/test_cases/t20007_sequence.svg | 48 +++---- docs/test_cases/t20008.md | 2 +- docs/test_cases/t20008_sequence.svg | 84 ++++++------ docs/test_cases/t20009.md | 2 +- docs/test_cases/t20009_sequence.svg | 84 ++++++------ docs/test_cases/t20010.md | 2 +- docs/test_cases/t20010_sequence.svg | 72 +++++----- docs/test_cases/t20011.md | 2 +- docs/test_cases/t20011_sequence.svg | 72 +++++----- docs/test_cases/t20012.md | 2 +- docs/test_cases/t20012_sequence.svg | 204 ++++++++++++++-------------- docs/test_cases/t20013.md | 2 +- docs/test_cases/t20013_sequence.svg | 60 ++++---- docs/test_cases/t20014.md | 2 +- docs/test_cases/t20014_sequence.svg | 72 +++++----- docs/test_cases/t20015.md | 2 +- docs/test_cases/t20015_sequence.svg | 24 ++-- docs/test_cases/t20016.md | 2 +- docs/test_cases/t20016_sequence.svg | 48 +++---- docs/test_cases/t20017.md | 2 +- docs/test_cases/t20017_sequence.svg | 48 +++---- docs/test_cases/t20018.md | 2 +- docs/test_cases/t20018_sequence.svg | 96 ++++++------- docs/test_cases/t20019.md | 2 +- docs/test_cases/t20019_sequence.svg | 84 ++++++------ docs/test_cases/t20020.md | 2 +- docs/test_cases/t20020_sequence.svg | 118 ++++++++-------- docs/test_cases/t20021.md | 2 +- docs/test_cases/t20021_sequence.svg | 106 +++++++-------- docs/test_cases/t20022.md | 2 +- docs/test_cases/t20022_sequence.svg | 36 ++--- docs/test_cases/t20023.md | 2 +- docs/test_cases/t20023_sequence.svg | 50 +++---- docs/test_cases/t20024.md | 2 +- docs/test_cases/t20024_sequence.svg | 88 ++++++------ docs/test_cases/t20025.md | 2 +- docs/test_cases/t20025_sequence.svg | 42 +++--- docs/test_cases/t20026.md | 2 +- docs/test_cases/t20026_sequence.svg | 24 ++-- docs/test_cases/t20027.md | 2 +- docs/test_cases/t20027_sequence.svg | 24 ++-- docs/test_cases/t20028.md | 2 +- docs/test_cases/t20028_sequence.svg | 44 +++--- docs/test_cases/t20029.md | 2 +- docs/test_cases/t20029_sequence.svg | 80 +++++------ docs/test_cases/t30001.md | 2 +- docs/test_cases/t30001_package.svg | 48 +++---- docs/test_cases/t30002.md | 2 +- docs/test_cases/t30002_package.svg | 94 ++++++------- docs/test_cases/t30003.md | 2 +- docs/test_cases/t30003_package.svg | 26 ++-- docs/test_cases/t30004.md | 2 +- docs/test_cases/t30004_package.svg | 30 ++-- docs/test_cases/t30005.md | 2 +- docs/test_cases/t30005_package.svg | 38 +++--- docs/test_cases/t30006.md | 2 +- docs/test_cases/t30006_package.svg | 16 +-- docs/test_cases/t30007.md | 2 +- docs/test_cases/t30007_package.svg | 20 +-- docs/test_cases/t30008.md | 2 +- docs/test_cases/t30008_package.svg | 34 ++--- docs/test_cases/t30009.md | 2 +- docs/test_cases/t30009_package.svg | 42 +++--- docs/test_cases/t30010.md | 2 +- docs/test_cases/t30011.md | 2 +- docs/test_cases/t40001.md | 2 +- docs/test_cases/t40001_include.svg | 30 ++-- docs/test_cases/t40002.md | 2 +- docs/test_cases/t40002_include.svg | 34 ++--- docs/test_cases/t40003.md | 2 +- docs/test_cases/t40003_include.svg | 50 +++---- 216 files changed, 3200 insertions(+), 3200 deletions(-) diff --git a/docs/test_cases/t00002.md b/docs/test_cases/t00002.md index 31016770..ed266022 100644 --- a/docs/test_cases/t00002.md +++ b/docs/test_cases/t00002.md @@ -556,7 +556,7 @@ private: } ], "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t00002_class.svg b/docs/test_cases/t00002_class.svg index a91d7588..3451d150 100644 --- a/docs/test_cases/t00002_class.svg +++ b/docs/test_cases/t00002_class.svg @@ -1,6 +1,6 @@ - + @@ -9,8 +9,8 @@ - - + + A @@ -21,8 +21,8 @@ foo_c() = 0 : void - - + + B @@ -31,8 +31,8 @@ foo_a() : void - - + + C @@ -41,8 +41,8 @@ foo_c() : void - - + + D @@ -53,15 +53,15 @@ foo_c() : void - + - + as : std::vector<A *> - - + + E @@ -72,20 +72,20 @@ foo_c() : void - + - + as : std::vector<A *> - + This is class A - + This is class B - + This is class D diff --git a/docs/test_cases/t00003.md b/docs/test_cases/t00003.md index cf7f20e1..ae7b55a8 100644 --- a/docs/test_cases/t00003.md +++ b/docs/test_cases/t00003.md @@ -690,7 +690,7 @@ int A::static_int = 1; } ], "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t00003_class.svg b/docs/test_cases/t00003_class.svg index 72d39e0b..2641a026 100644 --- a/docs/test_cases/t00003_class.svg +++ b/docs/test_cases/t00003_class.svg @@ -1,6 +1,6 @@ - + @@ -9,8 +9,8 @@ - - + + A @@ -62,74 +62,74 @@ sum(const double a, const double b) : int - + - + a_ : int - + - + auto_member : const unsigned long - + - + b_ : int - + - + c_ : int - + - + compare : std::function<bool (const int)> - + - + private_member : int - + - + protected_member : int - + - + public_member : int - + - + static_const_int : const int - + - + static_int : int diff --git a/docs/test_cases/t00004.md b/docs/test_cases/t00004.md index bfcce3d0..ae61edd4 100644 --- a/docs/test_cases/t00004.md +++ b/docs/test_cases/t00004.md @@ -478,7 +478,7 @@ public: } ], "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t00004_class.svg b/docs/test_cases/t00004_class.svg index 731eb2b5..48cbb700 100644 --- a/docs/test_cases/t00004_class.svg +++ b/docs/test_cases/t00004_class.svg @@ -1,6 +1,6 @@ - + @@ -9,16 +9,16 @@ - - + + B - - + + B::AA @@ -28,8 +28,8 @@ AA_3 - - + + A @@ -40,16 +40,16 @@ foo2() const : void - - + + A::AA - - + + A::AA::Lights @@ -59,16 +59,16 @@ Red - - + + A::AA::AAA - - + + C::B @@ -77,8 +77,8 @@ - - + + C @@ -87,38 +87,38 @@ - + - + b_int : B<int> - + - + t : T - - + + C::AA - - + + C::AA::AAA - - + + C::AA::CCC @@ -127,8 +127,8 @@ CCC_2 - - + + C::B @@ -137,15 +137,15 @@ - + - + b : V - - + + C::CC @@ -154,16 +154,16 @@ CC_2 - - + + detail::D - - + + detail::D::AA @@ -173,8 +173,8 @@ AA_3 - - + + detail::D::DD diff --git a/docs/test_cases/t00005.md b/docs/test_cases/t00005.md index 9067d37e..0f7ffb8a 100644 --- a/docs/test_cases/t00005.md +++ b/docs/test_cases/t00005.md @@ -464,7 +464,7 @@ public: } ], "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t00005_class.svg b/docs/test_cases/t00005_class.svg index a7678b6f..9206f127 100644 --- a/docs/test_cases/t00005_class.svg +++ b/docs/test_cases/t00005_class.svg @@ -1,6 +1,6 @@ - + @@ -9,205 +9,205 @@ - - + + A - - + + B - - + + C - - + + D - - + + E - - + + F - - + + G - - + + H - - + + I - - + + J - - + + K - - + + R - + - + a : A - + - + b : B * - + - + c : C & - + - + d : const D * - + - + e : const E & - + - + f : F && - + - + g : G ** - + - + h : H *** - + - + i : I *& - + - + j : volatile J * - + - + k : K * - + - + some_int : int - + - + some_int_pointer : int * - + - + some_int_pointer_pointer : int ** - + - + some_int_reference : int & diff --git a/docs/test_cases/t00006.md b/docs/test_cases/t00006.md index e23924a0..8997dcf1 100644 --- a/docs/test_cases/t00006.md +++ b/docs/test_cases/t00006.md @@ -633,7 +633,7 @@ public: } ], "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t00006_class.svg b/docs/test_cases/t00006_class.svg index 9451eb1f..a98f9e98 100644 --- a/docs/test_cases/t00006_class.svg +++ b/docs/test_cases/t00006_class.svg @@ -1,6 +1,6 @@ - + @@ -9,136 +9,136 @@ - - + + A - - + + B - - + + C - - + + D - - + + E - - + + F - - + + G - - + + H - - + + I - - + + J - - + + K - - + + L - - + + M - - + + N - - + + NN - - + + NNN - - + + custom_container @@ -147,15 +147,15 @@ - + - + data : std::vector<T> - - + + custom_container @@ -164,103 +164,103 @@ - - + + R - + - + a : std::vector<A> - + - + b : std::vector<B *> - + - + c : std::map<int,C> - + - + d : std::map<int,D *> - + - + e : custom_container<E> - + - + f : std::vector<std::vector<F>> - + - + g : std::map<int,std::vector<G *>> - + - + h : std::array<H,10> - + - + i : std::array<I *,5> - + - + j : J[10] - + - + k : K *[20] - + - + lm : std::vector<std::pair<L,M>> - + - + ns : std::tuple<N,NN,NNN> diff --git a/docs/test_cases/t00007.md b/docs/test_cases/t00007.md index da27e823..2fde0f70 100644 --- a/docs/test_cases/t00007.md +++ b/docs/test_cases/t00007.md @@ -158,7 +158,7 @@ public: } ], "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t00007_class.svg b/docs/test_cases/t00007_class.svg index f82dff9c..eb9933a7 100644 --- a/docs/test_cases/t00007_class.svg +++ b/docs/test_cases/t00007_class.svg @@ -1,6 +1,6 @@ - + @@ -9,57 +9,57 @@ - - + + A - - + + B - - + + C - - + + R - + - + a : std::unique_ptr<A> - + - + b : std::shared_ptr<B> - + - + c : std::weak_ptr<C> diff --git a/docs/test_cases/t00008.md b/docs/test_cases/t00008.md index 3b1716a5..07d1b9fb 100644 --- a/docs/test_cases/t00008.md +++ b/docs/test_cases/t00008.md @@ -509,7 +509,7 @@ template <> struct E::nested_template { } ], "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t00008_class.svg b/docs/test_cases/t00008_class.svg index 31b847f6..a49760b3 100644 --- a/docs/test_cases/t00008_class.svg +++ b/docs/test_cases/t00008_class.svg @@ -1,6 +1,6 @@ - + @@ -9,8 +9,8 @@ - - + + A @@ -19,50 +19,50 @@ - + - + comparator : CMP - + - + ints : std::array<int,N> - + - + pointer : T * - + - + reference : T & - + - + value : T - + - + values : std::vector<P> - - + + Vector @@ -71,15 +71,15 @@ - + - + values : std::vector<T> - - + + B @@ -88,15 +88,15 @@ - + - + template_template : C<T> - - + + B @@ -105,8 +105,8 @@ - - + + D @@ -118,23 +118,23 @@ add(int i) : void - + - + ints : B<int,Vector> - - + + E - - + + E::nested_template @@ -145,8 +145,8 @@ get(ET * d) : E::nested_template::DT * - - + + E::nested_template diff --git a/docs/test_cases/t00009.md b/docs/test_cases/t00009.md index 04789143..feb200f7 100644 --- a/docs/test_cases/t00009.md +++ b/docs/test_cases/t00009.md @@ -225,7 +225,7 @@ public: } ], "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t00009_class.svg b/docs/test_cases/t00009_class.svg index f5a505df..1dced416 100644 --- a/docs/test_cases/t00009_class.svg +++ b/docs/test_cases/t00009_class.svg @@ -1,6 +1,6 @@ - + @@ -9,8 +9,8 @@ - - + + A @@ -19,15 +19,15 @@ - + - + value : T - - + + A @@ -36,8 +36,8 @@ - - + + A @@ -46,8 +46,8 @@ - - + + A @@ -56,33 +56,33 @@ - - + + B - + - + aint : A<int> - + - + astring : A<std::string> * - + - + avector : A<std::vector<std::string>> & diff --git a/docs/test_cases/t00010.md b/docs/test_cases/t00010.md index eadcaa76..f110c51e 100644 --- a/docs/test_cases/t00010.md +++ b/docs/test_cases/t00010.md @@ -235,7 +235,7 @@ public: } ], "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t00010_class.svg b/docs/test_cases/t00010_class.svg index dc53d68b..5fc781e5 100644 --- a/docs/test_cases/t00010_class.svg +++ b/docs/test_cases/t00010_class.svg @@ -1,6 +1,6 @@ - + @@ -9,8 +9,8 @@ - - + + A @@ -19,22 +19,22 @@ - + - + first : T - + - + second : P - - + + A @@ -43,8 +43,8 @@ - - + + B @@ -53,15 +53,15 @@ - + - + astring : A<T,std::string> - - + + B @@ -70,19 +70,19 @@ - - + + C - + - + aintstring : B<int> diff --git a/docs/test_cases/t00011.md b/docs/test_cases/t00011.md index e5043624..7d46ccbc 100644 --- a/docs/test_cases/t00011.md +++ b/docs/test_cases/t00011.md @@ -190,7 +190,7 @@ public: } ], "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t00011_class.svg b/docs/test_cases/t00011_class.svg index 8d12bb1d..b1bd289a 100644 --- a/docs/test_cases/t00011_class.svg +++ b/docs/test_cases/t00011_class.svg @@ -1,6 +1,6 @@ - + @@ -9,8 +9,8 @@ - - + + D @@ -19,15 +19,15 @@ - + - + value : T - - + + A @@ -36,8 +36,8 @@ foo() : void - - + + B @@ -46,11 +46,11 @@ foo() : void - + - + m_a : A * diff --git a/docs/test_cases/t00012.md b/docs/test_cases/t00012.md index 3fcdb830..ae2f68c5 100644 --- a/docs/test_cases/t00012.md +++ b/docs/test_cases/t00012.md @@ -518,7 +518,7 @@ class R { } ], "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t00012_class.svg b/docs/test_cases/t00012_class.svg index a852a8eb..d7d9478f 100644 --- a/docs/test_cases/t00012_class.svg +++ b/docs/test_cases/t00012_class.svg @@ -1,6 +1,6 @@ - + @@ -9,8 +9,8 @@ - - + + A @@ -19,22 +19,22 @@ - + - + value : T - + - + values : std::variant<Ts...> - - + + B @@ -43,15 +43,15 @@ - + - + ints : std::array<int,sizeof...(Is)> - - + + C @@ -60,15 +60,15 @@ - + - + ints : std::array<T,sizeof...(Is)> - - + + A @@ -77,8 +77,8 @@ - - + + A @@ -87,8 +87,8 @@ - - + + B @@ -97,8 +97,8 @@ - - + + B @@ -107,8 +107,8 @@ - - + + C @@ -117,50 +117,50 @@ - - + + R - + - + a1 : A<int,std::string,float> - + - + a2 : A<int,std::string,bool> - + - + b1 : B<3,2,1> - + - + b2 : B<1,1,1,1> - + - + c1 : C<std::map<int,std::vector<std::vector<std::vector<std::string>>>>,3,3,3> - + Long template annotation diff --git a/docs/test_cases/t00013.md b/docs/test_cases/t00013.md index 9eb71a0b..d8aa1f0d 100644 --- a/docs/test_cases/t00013.md +++ b/docs/test_cases/t00013.md @@ -801,7 +801,7 @@ private: } ], "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t00013_class.svg b/docs/test_cases/t00013_class.svg index 5518c0ae..513f0d7a 100644 --- a/docs/test_cases/t00013_class.svg +++ b/docs/test_cases/t00013_class.svg @@ -1,6 +1,6 @@ - + @@ -9,8 +9,8 @@ - - + + ABCD::F @@ -19,15 +19,15 @@ - + - + f : T - - + + ABCD::F @@ -36,53 +36,53 @@ - - + + A - + - + a : int - - + + B - + - + b : int - - + + C - + - + c : int - - + + D @@ -91,15 +91,15 @@ print(R * r) : void - + - + d : int - - + + E @@ -108,15 +108,15 @@ - + - + e : T - - + + G @@ -125,22 +125,22 @@ - + - + args : std::tuple<Args...> - + - + g : T - - + + E @@ -149,8 +149,8 @@ - - + + G @@ -159,8 +159,8 @@ - - + + E @@ -169,8 +169,8 @@ - - + + R @@ -199,18 +199,18 @@ get_int_f(const ABCD::F<int> & f) : int - + - + estring : E<std::string> - + - + gintstring : G<int,float,std::string> diff --git a/docs/test_cases/t00014.md b/docs/test_cases/t00014.md index 078bf115..1cd2a18e 100644 --- a/docs/test_cases/t00014.md +++ b/docs/test_cases/t00014.md @@ -895,7 +895,7 @@ public: } ], "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t00014_class.svg b/docs/test_cases/t00014_class.svg index 88739a23..3f6e5785 100644 --- a/docs/test_cases/t00014_class.svg +++ b/docs/test_cases/t00014_class.svg @@ -1,6 +1,6 @@ - + @@ -9,8 +9,8 @@ - - + + A @@ -19,37 +19,37 @@ - + - + p : P - + - + t : T - - + + B - + - + value : std::string - - + + A @@ -58,8 +58,8 @@ - - + + A @@ -68,8 +68,8 @@ - - + + A @@ -78,8 +78,8 @@ - - + + A @@ -88,8 +88,8 @@ - - + + A @@ -98,8 +98,8 @@ - - + + A @@ -108,8 +108,8 @@ - - + + A @@ -118,8 +118,8 @@ - - + + A @@ -128,8 +128,8 @@ - - + + A @@ -138,8 +138,8 @@ - - + + A @@ -148,8 +148,8 @@ - - + + A @@ -158,8 +158,8 @@ - - + + A @@ -168,8 +168,8 @@ - - + + A @@ -178,8 +178,8 @@ - - + + A @@ -188,8 +188,8 @@ - - + + A @@ -198,8 +198,8 @@ - - + + R @@ -208,116 +208,116 @@ - + - + abool : APtr<bool> - + - + aboolfloat : AAPtr<bool,float> - + - + afloat : ASharedPtr<float> - + - + atfloat : AAPtr<T,float> - + - + bapair : PairPairBA<bool> - + - + boolstring : A<bool,std::string> - + - + bs : BVector - + - + bs2 : BVector2 - + - + bstringstring : BStringString - + - + cb : SimpleCallback<ACharString> - + - + floatstring : AStringPtr<float> - + - + gcb : GenericCallback<R::AWCharString> - + - + intstring : AIntString - + - + stringstring : AStringString - + - + vcb : VoidCallback - + - + vps : VectorPtr<B> diff --git a/docs/test_cases/t00015.md b/docs/test_cases/t00015.md index cdcde85c..e6380f3e 100644 --- a/docs/test_cases/t00015.md +++ b/docs/test_cases/t00015.md @@ -177,7 +177,7 @@ class B : public ns1::ns2::Anon { }; } ], "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t00015_class.svg b/docs/test_cases/t00015_class.svg index 64332034..ef532230 100644 --- a/docs/test_cases/t00015_class.svg +++ b/docs/test_cases/t00015_class.svg @@ -1,6 +1,6 @@ - + @@ -9,40 +9,40 @@ - - + + ns1::A - - + + ns1::ns2_v0_9_0::A - - + + ns1::Anon - - + + ns3::ns1::ns2::Anon - - + + ns3::B diff --git a/docs/test_cases/t00016.md b/docs/test_cases/t00016.md index 88da1ea7..74370a84 100644 --- a/docs/test_cases/t00016.md +++ b/docs/test_cases/t00016.md @@ -261,7 +261,7 @@ template <> struct is_numeric { } ], "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t00016_class.svg b/docs/test_cases/t00016_class.svg index 3a0b1971..63dad937 100644 --- a/docs/test_cases/t00016_class.svg +++ b/docs/test_cases/t00016_class.svg @@ -1,6 +1,6 @@ - + @@ -9,8 +9,8 @@ - - + + is_numeric @@ -21,8 +21,8 @@ value : enum - - + + is_numeric @@ -33,8 +33,8 @@ value : enum - - + + is_numeric @@ -45,8 +45,8 @@ value : enum - - + + is_numeric @@ -57,8 +57,8 @@ value : enum - - + + is_numeric @@ -69,8 +69,8 @@ value : enum - - + + is_numeric diff --git a/docs/test_cases/t00017.md b/docs/test_cases/t00017.md index 53bdbee4..c7cd3762 100644 --- a/docs/test_cases/t00017.md +++ b/docs/test_cases/t00017.md @@ -517,7 +517,7 @@ private: } ], "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t00017_class.svg b/docs/test_cases/t00017_class.svg index cd3d8ac0..b3734c43 100644 --- a/docs/test_cases/t00017_class.svg +++ b/docs/test_cases/t00017_class.svg @@ -1,6 +1,6 @@ - + @@ -9,96 +9,96 @@ - - + + A - - + + B - - + + C - - + + D - - + + E - - + + F - - + + G - - + + H - - + + I - - + + J - - + + K - - + + R @@ -107,32 +107,32 @@ R(int & some_int, C & cc, const E & ee, F && ff, I *& ii) : void - + - + some_int : int - + - + some_int_pointer : int * - + - + some_int_pointer_pointer : int ** - + - + some_int_reference : int & diff --git a/docs/test_cases/t00018.md b/docs/test_cases/t00018.md index 21a27ccc..fa3f6ced 100644 --- a/docs/test_cases/t00018.md +++ b/docs/test_cases/t00018.md @@ -474,7 +474,7 @@ void widget::draw(const clanguml::t00018::widget &w) } ], "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t00018_class.svg b/docs/test_cases/t00018_class.svg index 4d2acba7..46ebd383 100644 --- a/docs/test_cases/t00018_class.svg +++ b/docs/test_cases/t00018_class.svg @@ -1,6 +1,6 @@ - + @@ -9,8 +9,8 @@ - - + + impl::widget @@ -24,15 +24,15 @@ draw(const widget & w) : void - + - + n : int - - + + widget @@ -59,11 +59,11 @@ shown() const : bool - + - + pImpl : std::unique_ptr<impl::widget> diff --git a/docs/test_cases/t00019.md b/docs/test_cases/t00019.md index d01549f7..31b9feaa 100644 --- a/docs/test_cases/t00019.md +++ b/docs/test_cases/t00019.md @@ -648,7 +648,7 @@ class Base { } ], "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t00019_class.svg b/docs/test_cases/t00019_class.svg index 545b709f..e7dab7f4 100644 --- a/docs/test_cases/t00019_class.svg +++ b/docs/test_cases/t00019_class.svg @@ -1,6 +1,6 @@ - + @@ -9,8 +9,8 @@ - - + + Base @@ -26,8 +26,8 @@ m2() : std::string - - + + Layer1 @@ -40,8 +40,8 @@ m2() : std::string - - + + Layer2 @@ -52,8 +52,8 @@ all_calls_count() const : int - - + + Layer3 @@ -70,22 +70,22 @@ m2_calls() const : int - + - + m_m1_calls : int - + - + m_m2_calls : int - - + + Layer3 @@ -94,8 +94,8 @@ - - + + Layer2 @@ -104,8 +104,8 @@ - - + + Layer1 @@ -114,19 +114,19 @@ - - + + A - + - + layers : std::unique_ptr<Layer1<Layer2<Layer3<Base>>>> diff --git a/docs/test_cases/t00020.md b/docs/test_cases/t00020.md index 2c9b6b1e..b359cc7c 100644 --- a/docs/test_cases/t00020.md +++ b/docs/test_cases/t00020.md @@ -632,7 +632,7 @@ public: } ], "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t00020_class.svg b/docs/test_cases/t00020_class.svg index 23536e89..7317db8a 100644 --- a/docs/test_cases/t00020_class.svg +++ b/docs/test_cases/t00020_class.svg @@ -1,6 +1,6 @@ - + @@ -9,8 +9,8 @@ - - + + ProductA @@ -22,8 +22,8 @@ sell(int price) const = 0 : bool - - + + ProductA1 @@ -32,8 +32,8 @@ sell(int price) const : bool - - + + ProductA2 @@ -42,8 +42,8 @@ sell(int price) const : bool - - + + ProductB @@ -55,8 +55,8 @@ buy(int price) const = 0 : bool - - + + ProductB1 @@ -65,8 +65,8 @@ buy(int price) const : bool - - + + ProductB2 @@ -75,8 +75,8 @@ buy(int price) const : bool - - + + AbstractFactory @@ -87,8 +87,8 @@ make_b() const = 0 : std::unique_ptr<ProductB> - - + + Factory1 @@ -99,8 +99,8 @@ make_b() const : std::unique_ptr<ProductB> - - + + Factory2 diff --git a/docs/test_cases/t00021.md b/docs/test_cases/t00021.md index 9c9bfed4..a433d484 100644 --- a/docs/test_cases/t00021.md +++ b/docs/test_cases/t00021.md @@ -563,7 +563,7 @@ public: } ], "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t00021_class.svg b/docs/test_cases/t00021_class.svg index c0d2a21b..b2f91051 100644 --- a/docs/test_cases/t00021_class.svg +++ b/docs/test_cases/t00021_class.svg @@ -1,6 +1,6 @@ - + @@ -9,8 +9,8 @@ - - + + Visitor @@ -24,8 +24,8 @@ visit_B(const B & item) const = 0 : void - - + + Visitor1 @@ -36,8 +36,8 @@ visit_B(const B & item) const : void - - + + Visitor2 @@ -48,8 +48,8 @@ visit_B(const B & item) const : void - - + + Visitor3 @@ -60,8 +60,8 @@ visit_B(const B & item) const : void - - + + Item @@ -73,8 +73,8 @@ accept(const Visitor & visitor) const = 0 : void - - + + A @@ -83,8 +83,8 @@ accept(const Visitor & visitor) const : void - - + + B diff --git a/docs/test_cases/t00022.md b/docs/test_cases/t00022.md index 51b4c71f..d982b5c0 100644 --- a/docs/test_cases/t00022.md +++ b/docs/test_cases/t00022.md @@ -270,7 +270,7 @@ protected: } ], "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t00022_class.svg b/docs/test_cases/t00022_class.svg index c0795d31..ec021b1b 100644 --- a/docs/test_cases/t00022_class.svg +++ b/docs/test_cases/t00022_class.svg @@ -1,6 +1,6 @@ - + @@ -9,8 +9,8 @@ - - + + A @@ -23,8 +23,8 @@ template_method() : void - - + + A1 @@ -35,8 +35,8 @@ method2() : void - - + + A2 diff --git a/docs/test_cases/t00023.md b/docs/test_cases/t00023.md index 534be813..21a1338b 100644 --- a/docs/test_cases/t00023.md +++ b/docs/test_cases/t00023.md @@ -344,7 +344,7 @@ private: } ], "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t00023_class.svg b/docs/test_cases/t00023_class.svg index d86ea4af..7bdcea3e 100644 --- a/docs/test_cases/t00023_class.svg +++ b/docs/test_cases/t00023_class.svg @@ -1,6 +1,6 @@ - + @@ -9,8 +9,8 @@ - - + + Strategy @@ -22,8 +22,8 @@ algorithm() = 0 : void - - + + StrategyA @@ -32,8 +32,8 @@ algorithm() : void - - + + StrategyB @@ -42,8 +42,8 @@ algorithm() : void - - + + StrategyC @@ -52,8 +52,8 @@ algorithm() : void - - + + Context @@ -65,11 +65,11 @@ apply() : void - + - + m_strategy : std::unique_ptr<Strategy> diff --git a/docs/test_cases/t00024.md b/docs/test_cases/t00024.md index 295c1dc1..5508974c 100644 --- a/docs/test_cases/t00024.md +++ b/docs/test_cases/t00024.md @@ -379,7 +379,7 @@ private: } ], "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t00024_class.svg b/docs/test_cases/t00024_class.svg index 2e6d032a..890008e7 100644 --- a/docs/test_cases/t00024_class.svg +++ b/docs/test_cases/t00024_class.svg @@ -1,6 +1,6 @@ - + @@ -9,8 +9,8 @@ - - + + Target @@ -24,8 +24,8 @@ m2() = 0 : void - - + + Target1 @@ -36,8 +36,8 @@ m2() : void - - + + Target2 @@ -48,8 +48,8 @@ m2() : void - - + + Proxy @@ -63,11 +63,11 @@ m2() : void - + - + m_target : std::shared_ptr<Target> diff --git a/docs/test_cases/t00025.md b/docs/test_cases/t00025.md index 31e323fe..eb71638f 100644 --- a/docs/test_cases/t00025.md +++ b/docs/test_cases/t00025.md @@ -380,7 +380,7 @@ public: } ], "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t00025_class.svg b/docs/test_cases/t00025_class.svg index 653e60db..1137bd94 100644 --- a/docs/test_cases/t00025_class.svg +++ b/docs/test_cases/t00025_class.svg @@ -1,6 +1,6 @@ - + @@ -9,8 +9,8 @@ - - + + Target1 @@ -21,8 +21,8 @@ m2() : void - - + + Target2 @@ -33,8 +33,8 @@ m2() : void - - + + Proxy @@ -50,15 +50,15 @@ m2() : void - + - + m_target : std::shared_ptr<T> - - + + Proxy @@ -67,8 +67,8 @@ - - + + Proxy @@ -77,26 +77,26 @@ - - + + ProxyHolder - + - + proxy1 : Proxy<Target1> - + - + proxy2 : Proxy<Target2> diff --git a/docs/test_cases/t00026.md b/docs/test_cases/t00026.md index 45254aaa..683c93bc 100644 --- a/docs/test_cases/t00026.md +++ b/docs/test_cases/t00026.md @@ -504,7 +504,7 @@ struct StringMemento { } ], "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t00026_class.svg b/docs/test_cases/t00026_class.svg index f3a4595a..a4963d76 100644 --- a/docs/test_cases/t00026_class.svg +++ b/docs/test_cases/t00026_class.svg @@ -1,6 +1,6 @@ - + @@ -9,8 +9,8 @@ - - + + Memento @@ -24,15 +24,15 @@ value() const : T - + - + m_value : T - - + + Originator @@ -52,15 +52,15 @@ set(T && v) : void - + - + m_value : T - - + + Caretaker @@ -73,15 +73,15 @@ state(const std::string & n) : Memento<T> & - + - + m_mementos : std::unordered_map<std::string,Memento<T>> - - + + Caretaker @@ -90,8 +90,8 @@ - - + + Originator @@ -100,26 +100,26 @@ - - + + StringMemento - + - + caretaker : Caretaker<std::string> - + - + originator : Originator<std::string> diff --git a/docs/test_cases/t00027.md b/docs/test_cases/t00027.md index 0a5a9064..e63aaa26 100644 --- a/docs/test_cases/t00027.md +++ b/docs/test_cases/t00027.md @@ -632,7 +632,7 @@ struct Window { } ], "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t00027_class.svg b/docs/test_cases/t00027_class.svg index 4ce38dd7..06c34e8f 100644 --- a/docs/test_cases/t00027_class.svg +++ b/docs/test_cases/t00027_class.svg @@ -1,6 +1,6 @@ - + @@ -9,8 +9,8 @@ - - + + Shape @@ -22,16 +22,16 @@ display() = 0 : void - - + + Line - - + + Line @@ -42,16 +42,16 @@ display() : void - - + + Text - - + + Text @@ -62,8 +62,8 @@ display() : void - - + + ShapeDecorator @@ -72,8 +72,8 @@ display() = 0 : void - - + + Color @@ -84,8 +84,8 @@ display() : void - - + + Weight @@ -96,8 +96,8 @@ display() : void - - + + Line @@ -106,8 +106,8 @@ - - + + Line @@ -116,8 +116,8 @@ - - + + Text @@ -126,8 +126,8 @@ - - + + Text @@ -136,40 +136,40 @@ - - + + Window - + - + border : Line<Color,Weight> - + - + description : Text<Color> - + - + divider : Line<Color> - + - + title : Text<Color,Weight> diff --git a/docs/test_cases/t00028.md b/docs/test_cases/t00028.md index 6f5bd9b3..0a4397b2 100644 --- a/docs/test_cases/t00028.md +++ b/docs/test_cases/t00028.md @@ -421,7 +421,7 @@ class R { } ], "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t00028_class.svg b/docs/test_cases/t00028_class.svg index 653195ff..091eb379 100644 --- a/docs/test_cases/t00028_class.svg +++ b/docs/test_cases/t00028_class.svg @@ -1,6 +1,6 @@ - + @@ -9,54 +9,54 @@ - - + + A - + A class note. - - + + B - + B class note. - - + + C - + C class note. - - + + D - + D class note. - - + + E @@ -65,26 +65,26 @@ - + - + param : T - + E template class note. - - + + G - - + + F @@ -94,11 +94,11 @@ three - + F enum note. - - + + E @@ -107,8 +107,8 @@ - - + + R @@ -117,55 +117,55 @@ R(C & c) : void - + - + aaa : A - + - + bbb : B * - + - + ccc : C & - + - + ddd : std::vector<std::shared_ptr<D>> - + - + eee : E<int> - + - + ggg : G ** - + R class note. - + R contains an instance of A. - + Reference to C. diff --git a/docs/test_cases/t00029.md b/docs/test_cases/t00029.md index 7c6b3c57..d56af14a 100644 --- a/docs/test_cases/t00029.md +++ b/docs/test_cases/t00029.md @@ -286,7 +286,7 @@ struct R { } ], "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t00029_class.svg b/docs/test_cases/t00029_class.svg index 6f7f0f5d..121a4039 100644 --- a/docs/test_cases/t00029_class.svg +++ b/docs/test_cases/t00029_class.svg @@ -1,6 +1,6 @@ - + @@ -9,16 +9,16 @@ - - + + A - - + + C @@ -27,15 +27,15 @@ - + - + param : T - - + + E @@ -45,65 +45,65 @@ three - - + + G1 - - + + G2 - - + + G3 - - + + G4 - - + + R - + - + g1 : G1 - + - + g3 : G3 & - + - + g4 : std::shared_ptr<G4> diff --git a/docs/test_cases/t00030.md b/docs/test_cases/t00030.md index 0ed5b7bf..7d9709f4 100644 --- a/docs/test_cases/t00030.md +++ b/docs/test_cases/t00030.md @@ -255,7 +255,7 @@ struct R { } ], "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t00030_class.svg b/docs/test_cases/t00030_class.svg index 5b46bc50..0e6f5d6d 100644 --- a/docs/test_cases/t00030_class.svg +++ b/docs/test_cases/t00030_class.svg @@ -1,6 +1,6 @@ - + @@ -9,87 +9,87 @@ - - + + A - - + + B - - + + C - - + + D - - + + E - - + + R - + - + aaa : A - + - + bbb : std::vector<B> - + - + ccc : std::vector<C> - + - + ddd : D - + - + eee : E * diff --git a/docs/test_cases/t00031.md b/docs/test_cases/t00031.md index 8a22593d..3dbc9e29 100644 --- a/docs/test_cases/t00031.md +++ b/docs/test_cases/t00031.md @@ -276,7 +276,7 @@ struct R { } ], "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t00031_class.svg b/docs/test_cases/t00031_class.svg index 16a7abd8..52e91247 100644 --- a/docs/test_cases/t00031_class.svg +++ b/docs/test_cases/t00031_class.svg @@ -1,33 +1,33 @@ - + - + - + - - - + + + A - - + + B @@ -37,8 +37,8 @@ three - - + + @@ -48,23 +48,23 @@ - + - + ttt : T - - + + D - - + + C @@ -73,40 +73,40 @@ - - + + R - + - + aaa : A * - + - + bbb : std::vector<B> - + - + ccc : C<int> - + - + ddd : D * diff --git a/docs/test_cases/t00032.md b/docs/test_cases/t00032.md index 0185e32f..435657b7 100644 --- a/docs/test_cases/t00032.md +++ b/docs/test_cases/t00032.md @@ -389,7 +389,7 @@ struct R { } ], "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t00032_class.svg b/docs/test_cases/t00032_class.svg index add56020..cbfa558c 100644 --- a/docs/test_cases/t00032_class.svg +++ b/docs/test_cases/t00032_class.svg @@ -1,6 +1,6 @@ - + @@ -9,24 +9,24 @@ - - + + Base - - + + TBase - - + + A @@ -35,8 +35,8 @@ operator()() : void - - + + B @@ -45,8 +45,8 @@ operator()() : void - - + + C @@ -55,8 +55,8 @@ operator()() : void - - + + Overload @@ -65,15 +65,15 @@ - + - + counter : L - - + + Overload @@ -82,19 +82,19 @@ - - + + R - + - + overload : Overload<TBase,int,A,B,C> diff --git a/docs/test_cases/t00033.md b/docs/test_cases/t00033.md index a9763505..0b5fd8f8 100644 --- a/docs/test_cases/t00033.md +++ b/docs/test_cases/t00033.md @@ -349,7 +349,7 @@ struct R { } ], "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t00033_class.svg b/docs/test_cases/t00033_class.svg index 51105982..8d64584a 100644 --- a/docs/test_cases/t00033_class.svg +++ b/docs/test_cases/t00033_class.svg @@ -1,6 +1,6 @@ - + @@ -9,8 +9,8 @@ - - + + A @@ -19,15 +19,15 @@ - + - + aaa : T - - + + B @@ -36,15 +36,15 @@ - + - + bbb : T - - + + C @@ -53,30 +53,30 @@ - + - + ccc : T - - + + D - + - + ddd : int - - + + C @@ -85,8 +85,8 @@ - - + + B @@ -95,8 +95,8 @@ - - + + A @@ -105,19 +105,19 @@ - - + + R - + - + abc : A<B<std::unique_ptr<C<D>>>> diff --git a/docs/test_cases/t00034.md b/docs/test_cases/t00034.md index a9e4e350..36682d90 100644 --- a/docs/test_cases/t00034.md +++ b/docs/test_cases/t00034.md @@ -321,7 +321,7 @@ struct R { } ], "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t00034_class.svg b/docs/test_cases/t00034_class.svg index 0df0e7a7..f65f8c73 100644 --- a/docs/test_cases/t00034_class.svg +++ b/docs/test_cases/t00034_class.svg @@ -1,6 +1,6 @@ - + @@ -9,8 +9,8 @@ - - + + Void @@ -21,8 +21,8 @@ operator==(const Void &) constexpr const : bool - - + + lift_void @@ -31,8 +31,8 @@ - - + + lift_void @@ -41,8 +41,8 @@ - - + + drop_void @@ -51,8 +51,8 @@ - - + + drop_void @@ -61,34 +61,34 @@ - - + + A - - + + R - + - + la : lift_void_t<A> * - + - + lv : lift_void_t<void> * diff --git a/docs/test_cases/t00035.md b/docs/test_cases/t00035.md index aae8371d..9c4aa367 100644 --- a/docs/test_cases/t00035.md +++ b/docs/test_cases/t00035.md @@ -150,7 +150,7 @@ struct Right { }; } ], "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t00035_class.svg b/docs/test_cases/t00035_class.svg index 740e2255..fd6d8c44 100644 --- a/docs/test_cases/t00035_class.svg +++ b/docs/test_cases/t00035_class.svg @@ -1,6 +1,6 @@ - + @@ -9,40 +9,40 @@ - - + + Top - - + + Left - - + + Center - - + + Bottom - - + + Right diff --git a/docs/test_cases/t00036.md b/docs/test_cases/t00036.md index 7bf533f2..8c54d638 100644 --- a/docs/test_cases/t00036.md +++ b/docs/test_cases/t00036.md @@ -262,7 +262,7 @@ struct DImpl : public ns2::ns22::D { }; } ], "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t00036_class.svg b/docs/test_cases/t00036_class.svg index 39e9cca2..bc45b2cd 100644 --- a/docs/test_cases/t00036_class.svg +++ b/docs/test_cases/t00036_class.svg @@ -1,6 +1,6 @@ - + @@ -9,23 +9,23 @@ - + ns1 - + ns11 - + ns111 - + ns2 - + ns22 - - + + E @@ -34,8 +34,8 @@ yellow - - + + A @@ -44,15 +44,15 @@ - + - + a : T - - + + A @@ -61,23 +61,23 @@ - - + + B - + - + a_int : A<int> - - + + C diff --git a/docs/test_cases/t00037.md b/docs/test_cases/t00037.md index c6aa9613..bcaac76e 100644 --- a/docs/test_cases/t00037.md +++ b/docs/test_cases/t00037.md @@ -256,7 +256,7 @@ struct A { } ], "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t00037_class.svg b/docs/test_cases/t00037_class.svg index 0833994b..df1a7111 100644 --- a/docs/test_cases/t00037_class.svg +++ b/docs/test_cases/t00037_class.svg @@ -1,6 +1,6 @@ - + @@ -9,88 +9,88 @@ - - + + ST - + - + dimensions : ST::(anonymous_662) - + - + units : ST::(anonymous_792) - - + + ST::(dimensions) - + - + t : double - + - + x : double - + - + y : double - + - + z : double - - + + ST::(units) - + - + c : double - + - + h : double - - + + A @@ -99,11 +99,11 @@ A() : void - + - + st : ST diff --git a/docs/test_cases/t00038.md b/docs/test_cases/t00038.md index daf1fe25..543bf7bd 100644 --- a/docs/test_cases/t00038.md +++ b/docs/test_cases/t00038.md @@ -468,7 +468,7 @@ struct map - + @@ -9,8 +9,8 @@ - - + + thirdparty::ns1::color_t @@ -20,16 +20,16 @@ blue - - + + thirdparty::ns1::E - - + + property_t @@ -39,47 +39,47 @@ property_c - - + + A - - + + B - - + + C - - + + key_t - + - + key : std::string - - + + map @@ -88,8 +88,8 @@ - - + + map @@ -98,8 +98,8 @@ - - + + map @@ -108,8 +108,8 @@ - - + + map @@ -118,8 +118,8 @@ - - + + map diff --git a/docs/test_cases/t00039.md b/docs/test_cases/t00039.md index 7633c52c..0df87fbb 100644 --- a/docs/test_cases/t00039.md +++ b/docs/test_cases/t00039.md @@ -570,7 +570,7 @@ template struct FFF : public FF { } ], "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t00039_class.svg b/docs/test_cases/t00039_class.svg index c3e11b3a..c3dcfe24 100644 --- a/docs/test_cases/t00039_class.svg +++ b/docs/test_cases/t00039_class.svg @@ -1,6 +1,6 @@ - + @@ -9,95 +9,95 @@ - - + + C - - + + D - - + + E - - + + CD - - + + DE - - + + CDE - - + + A - - + + AA - - + + AAA - + - + b : B * - - + + ns2::AAAA - - + + ns3::F @@ -106,15 +106,15 @@ - + - + t : T * - - + + ns3::FF @@ -123,15 +123,15 @@ - + - + m : M * - - + + ns3::FE @@ -140,15 +140,15 @@ - + - + m : M * - - + + ns3::FFF @@ -157,11 +157,11 @@ - + - + n : N * diff --git a/docs/test_cases/t00040.md b/docs/test_cases/t00040.md index 0bd4d71c..03f0e663 100644 --- a/docs/test_cases/t00040.md +++ b/docs/test_cases/t00040.md @@ -273,7 +273,7 @@ struct R { } ], "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t00040_class.svg b/docs/test_cases/t00040_class.svg index fe3fd4a4..08fd164c 100644 --- a/docs/test_cases/t00040_class.svg +++ b/docs/test_cases/t00040_class.svg @@ -1,6 +1,6 @@ - + @@ -9,8 +9,8 @@ - - + + A @@ -19,23 +19,23 @@ get_a() : int - + - + ii_ : int - - + + AA - - + + AAA @@ -44,15 +44,15 @@ get_aaa() : int - + - + b : B * - - + + R diff --git a/docs/test_cases/t00041.md b/docs/test_cases/t00041.md index 4d596680..c0d02616 100644 --- a/docs/test_cases/t00041.md +++ b/docs/test_cases/t00041.md @@ -358,7 +358,7 @@ struct NM : public N { }; } ], "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t00041_class.svg b/docs/test_cases/t00041_class.svg index f04a5b39..85d59cd4 100644 --- a/docs/test_cases/t00041_class.svg +++ b/docs/test_cases/t00041_class.svg @@ -1,6 +1,6 @@ - + @@ -9,47 +9,47 @@ - - + + R - - + + D - + - + rr : RR * - - + + E - - + + F - - + + RR @@ -58,53 +58,53 @@ foo(H * h) : void - + - + e : E * - + - + f : F * - + - + g : detail::G * - - + + RRR - - + + ns1::N - - + + ns1::NN - - + + ns1::NM diff --git a/docs/test_cases/t00042.md b/docs/test_cases/t00042.md index 2a719134..35547fd5 100644 --- a/docs/test_cases/t00042.md +++ b/docs/test_cases/t00042.md @@ -285,7 +285,7 @@ struct R { } ], "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t00042_class.svg b/docs/test_cases/t00042_class.svg index f62601f0..af9681d4 100644 --- a/docs/test_cases/t00042_class.svg +++ b/docs/test_cases/t00042_class.svg @@ -1,6 +1,6 @@ - + @@ -9,8 +9,8 @@ - - + + A @@ -19,15 +19,15 @@ - + - + a : T - - + + A @@ -36,15 +36,15 @@ - + - + a : void * - - + + B @@ -53,22 +53,22 @@ - + - + b : T - + - + bb : K - - + + A @@ -77,8 +77,8 @@ - - + + A @@ -87,8 +87,8 @@ - - + + B diff --git a/docs/test_cases/t00043.md b/docs/test_cases/t00043.md index fdd65246..63f4bbdf 100644 --- a/docs/test_cases/t00043.md +++ b/docs/test_cases/t00043.md @@ -569,7 +569,7 @@ struct J { } ], "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t00043_class.svg b/docs/test_cases/t00043_class.svg index da86b721..ee7c047c 100644 --- a/docs/test_cases/t00043_class.svg +++ b/docs/test_cases/t00043_class.svg @@ -1,6 +1,6 @@ - + @@ -9,22 +9,22 @@ - + dependants - + dependencies - - + + A - - + + B @@ -33,8 +33,8 @@ b(dependants::A * a) : void - - + + BB @@ -43,8 +43,8 @@ bb(dependants::A * a) : void - - + + C @@ -53,8 +53,8 @@ c(dependants::B * b) : void - - + + D @@ -65,8 +65,8 @@ dd(dependants::BB * bb) : void - - + + E @@ -75,24 +75,24 @@ e(dependants::D * d) : void - - + + G - - + + GG - - + + H @@ -103,8 +103,8 @@ hh(dependencies::GG * gg) : void - - + + I @@ -113,8 +113,8 @@ i(dependencies::H * h) : void - - + + J diff --git a/docs/test_cases/t00044.md b/docs/test_cases/t00044.md index b7773bbb..4724ac46 100644 --- a/docs/test_cases/t00044.md +++ b/docs/test_cases/t00044.md @@ -406,7 +406,7 @@ struct R { } ], "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t00044_class.svg b/docs/test_cases/t00044_class.svg index 638fae04..36341ad3 100644 --- a/docs/test_cases/t00044_class.svg +++ b/docs/test_cases/t00044_class.svg @@ -1,6 +1,6 @@ - + @@ -9,8 +9,8 @@ - - + + signal_handler @@ -19,8 +19,8 @@ - - + + sink @@ -34,15 +34,15 @@ get_signal<CastTo>() : CastTo * - + - + signal : signal_t * - - + + signal_handler @@ -51,8 +51,8 @@ - - + + sink @@ -61,23 +61,23 @@ - - + + R - + - + sink1 : sink<signal_handler<void (int),bool>> - - + + signal_handler @@ -86,8 +86,8 @@ - - + + sink diff --git a/docs/test_cases/t00045.md b/docs/test_cases/t00045.md index 2a9521a9..7026620e 100644 --- a/docs/test_cases/t00045.md +++ b/docs/test_cases/t00045.md @@ -421,7 +421,7 @@ public: } ], "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t00045_class.svg b/docs/test_cases/t00045_class.svg index 35bbef3e..f07247a0 100644 --- a/docs/test_cases/t00045_class.svg +++ b/docs/test_cases/t00045_class.svg @@ -1,6 +1,6 @@ - + @@ -9,32 +9,32 @@ - - + + A - - + + AA - - + + AAA - - + + AAAA @@ -43,71 +43,71 @@ - + - + t : T - - + + ns1::A - - + + ns1::ns2::A - - + + ns1::ns2::B - - + + ns1::ns2::C - - + + ns1::ns2::D - - + + ns1::ns2::E - - + + ns1::ns2::AAA - - + + ns1::ns2::R @@ -116,32 +116,32 @@ foo(AA & aa) : void - + - + a : ns1::ns2::A * - + - + ns1_a : ns1::A * - + - + ns1_ns2_a : ns1::ns2::A * - + - + root_a : ::A * diff --git a/docs/test_cases/t00046.md b/docs/test_cases/t00046.md index 16e1c142..cb44631e 100644 --- a/docs/test_cases/t00046.md +++ b/docs/test_cases/t00046.md @@ -360,7 +360,7 @@ public: } ], "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t00046_class.svg b/docs/test_cases/t00046_class.svg index ba1bbef4..c586a62d 100644 --- a/docs/test_cases/t00046_class.svg +++ b/docs/test_cases/t00046_class.svg @@ -1,6 +1,6 @@ - + @@ -9,62 +9,62 @@ - + ns1 - + ns2 - - + + A - - + + A - - + + B - - + + C - - + + D - - + + E - - + + R @@ -73,51 +73,51 @@ foo(AA & aa) : void - + - + a : ns1::ns2::A * - + - + i : std::vector<std::uint8_t> - + - + ns1_a : ns1::A * - + - + ns1_ns2_a : ns1::ns2::A * - + - + root_a : ::A * - - + + A - - + + AA diff --git a/docs/test_cases/t00047.md b/docs/test_cases/t00047.md index 0cf4a5c3..c37f8427 100644 --- a/docs/test_cases/t00047.md +++ b/docs/test_cases/t00047.md @@ -184,7 +184,7 @@ using conditional = typename conditional_t::type; } ], "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t00047_class.svg b/docs/test_cases/t00047_class.svg index 250986d9..8b796a4c 100644 --- a/docs/test_cases/t00047_class.svg +++ b/docs/test_cases/t00047_class.svg @@ -1,6 +1,6 @@ - + @@ -9,8 +9,8 @@ - - + + conditional_t @@ -19,8 +19,8 @@ - - + + conditional_t @@ -29,8 +29,8 @@ - - + + conditional_t @@ -39,8 +39,8 @@ - - + + conditional_t diff --git a/docs/test_cases/t00048.md b/docs/test_cases/t00048.md index 0347fcf9..ded555a9 100644 --- a/docs/test_cases/t00048.md +++ b/docs/test_cases/t00048.md @@ -484,7 +484,7 @@ template struct BaseTemplate { } ], "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t00048_class.svg b/docs/test_cases/t00048_class.svg index e273ed57..145bd83c 100644 --- a/docs/test_cases/t00048_class.svg +++ b/docs/test_cases/t00048_class.svg @@ -1,6 +1,6 @@ - + @@ -9,8 +9,8 @@ - - + + Base @@ -19,15 +19,15 @@ foo() = 0 : void - + - + base : int - - + + BaseTemplate @@ -38,15 +38,15 @@ foo() = 0 : void - + - + base : T - - + + B @@ -55,15 +55,15 @@ foo() : void - + - + b : int - - + + BTemplate @@ -74,15 +74,15 @@ foo() : void - + - + b : T - - + + A @@ -91,15 +91,15 @@ foo() : void - + - + a : int - - + + ATemplate @@ -110,11 +110,11 @@ foo() : void - + - + a : T diff --git a/docs/test_cases/t00049.md b/docs/test_cases/t00049.md index aefd4148..881d7aed 100644 --- a/docs/test_cases/t00049.md +++ b/docs/test_cases/t00049.md @@ -289,7 +289,7 @@ struct R { } ], "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t00049_class.svg b/docs/test_cases/t00049_class.svg index 37f291e6..a8548521 100644 --- a/docs/test_cases/t00049_class.svg +++ b/docs/test_cases/t00049_class.svg @@ -1,6 +1,6 @@ - + @@ -9,8 +9,8 @@ - - + + A @@ -21,15 +21,15 @@ get_a() : T & - + - + a : T - - + + A @@ -38,8 +38,8 @@ - - + + A @@ -48,8 +48,8 @@ - - + + A @@ -58,8 +58,8 @@ - - + + R @@ -70,25 +70,25 @@ set_int_map(A<intmap> && int_map) : void - + - + a_int_map : A<intmap> - + - + a_string : A<thestring> - + - + a_vector_string : A<string_vector> diff --git a/docs/test_cases/t00050.md b/docs/test_cases/t00050.md index c80ba98f..d41cc3e6 100644 --- a/docs/test_cases/t00050.md +++ b/docs/test_cases/t00050.md @@ -484,7 +484,7 @@ class NoComment { }; } ], "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t00050_class.svg b/docs/test_cases/t00050_class.svg index fb19dd43..0e1802f3 100644 --- a/docs/test_cases/t00050_class.svg +++ b/docs/test_cases/t00050_class.svg @@ -1,6 +1,6 @@ - + @@ -9,40 +9,40 @@ - - + + A - - + + B - - + + C - - + + utils::D - - + + E @@ -52,8 +52,8 @@ E3 - - + + F @@ -62,43 +62,43 @@ - + - + t : T[N] - + - + v : V - - + + G - - + + NoComment - + Lorem ipsum dolor sit - + Lorem ipsum dolor sit - + Lorem ipsum dolor sit amet consectetur adipiscing elit, urna consequat felis vehicula class ultricies mollis dictumst, aenean non a in donec nulla. @@ -125,50 +125,50 @@ imperdiet praesent magnis ridiculus congue gravida curabitur dictum sagittis, enim et magna sit inceptos sodales parturient pharetra mollis, aenean vel nostra tellus commodo pretium sapien sociosqu. - + This is a short description of class G. - + This is an intermediate description of class G. - + This is a long description of class G. - + Lorem ipsum - + TODO 1. Write meaningful comment - + TODO 2. Write tests - + TODO 3. Implement - + Long comment example - + TODO Implement... - + Simple array wrapper. - + Template parameters diff --git a/docs/test_cases/t00051.md b/docs/test_cases/t00051.md index ef899907..31247856 100644 --- a/docs/test_cases/t00051.md +++ b/docs/test_cases/t00051.md @@ -553,7 +553,7 @@ A::custom_thread2 A::start_thread2() } ], "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t00051_class.svg b/docs/test_cases/t00051_class.svg index b27fc7a4..c681bae5 100644 --- a/docs/test_cases/t00051_class.svg +++ b/docs/test_cases/t00051_class.svg @@ -1,6 +1,6 @@ - + @@ -9,8 +9,8 @@ - - + + B @@ -26,22 +26,22 @@ ff() : void - + - + f_ : F - + - + ff_ : FF - - + + B<(lambda at ../../tests/t00051/t00051.cc:43:18),(lambda at ../../tests/t00051/t00051.cc:43:27)> @@ -55,22 +55,22 @@ ff() : void - + - + f_ : (lambda at ../../tests/t00051/t00051.cc:43:18) - + - + ff_ : (lambda at ../../tests/t00051/t00051.cc:43:27) - - + + A @@ -85,8 +85,8 @@ start_thread3() : B<(lambda at ../../tests/t00051/t00051.cc:43:18),(lambda at ../../tests/t00051/t00051.cc:43:27)> - - + + A::custom_thread1 @@ -95,8 +95,8 @@ custom_thread1<Function,Args...>(Function && f, Args &&... args) : void - - + + A::custom_thread2 diff --git a/docs/test_cases/t00052.md b/docs/test_cases/t00052.md index e6617624..6dcab35e 100644 --- a/docs/test_cases/t00052.md +++ b/docs/test_cases/t00052.md @@ -372,7 +372,7 @@ struct R { } ], "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t00052_class.svg b/docs/test_cases/t00052_class.svg index 8b95738f..eefb0222 100644 --- a/docs/test_cases/t00052_class.svg +++ b/docs/test_cases/t00052_class.svg @@ -1,6 +1,6 @@ - + @@ -9,8 +9,8 @@ - - + + A @@ -21,8 +21,8 @@ aa<F,Q>(F && f, Q q) : void - - + + B @@ -35,8 +35,8 @@ bb<F>(F && f, T t) : T - - + + C @@ -47,8 +47,8 @@ c<P>(P p) : T - - + + B @@ -57,8 +57,8 @@ - - + + C @@ -67,33 +67,33 @@ - - + + R - + - + a : A - + - + b : B<int> - + - + c : C<int> diff --git a/docs/test_cases/t00053.md b/docs/test_cases/t00053.md index 22c6bc0b..59b5331a 100644 --- a/docs/test_cases/t00053.md +++ b/docs/test_cases/t00053.md @@ -384,7 +384,7 @@ enum class j { jjj }; } ], "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t00053_class.svg b/docs/test_cases/t00053_class.svg index 54618f23..bdb3d114 100644 --- a/docs/test_cases/t00053_class.svg +++ b/docs/test_cases/t00053_class.svg @@ -1,6 +1,6 @@ - + @@ -9,72 +9,72 @@ - - + + A - - + + C - - + + E - - + + F - - + + a - - + + c - - + + e - - + + f - - + + h @@ -82,8 +82,8 @@ hhh - - + + j @@ -91,56 +91,56 @@ jjj - - + + b - - + + d - - + + g - - + + B - - + + D - - + + G - - + + i diff --git a/docs/test_cases/t00054.md b/docs/test_cases/t00054.md index e5374b58..3c70c602 100644 --- a/docs/test_cases/t00054.md +++ b/docs/test_cases/t00054.md @@ -426,7 +426,7 @@ enum class j { jjj }; } ], "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t00054_class.svg b/docs/test_cases/t00054_class.svg index 1c916d21..f1e95174 100644 --- a/docs/test_cases/t00054_class.svg +++ b/docs/test_cases/t00054_class.svg @@ -1,6 +1,6 @@ - + @@ -9,28 +9,28 @@ - + detail - + detail2 - + detail3 - + detail4 - - + + d - - + + a @@ -40,8 +40,8 @@ - - + + c @@ -51,8 +51,8 @@ - - + + e @@ -62,40 +62,40 @@ - - + + C - - + + F - - + + D - - + + E - - + + A @@ -104,8 +104,8 @@ - - + + B @@ -114,8 +114,8 @@ - - + + f @@ -124,8 +124,8 @@ - - + + G @@ -133,8 +133,8 @@ - - + + h @@ -143,8 +143,8 @@ hhh - - + + i @@ -153,8 +153,8 @@ iii - - + + j @@ -163,16 +163,16 @@ jjj - - + + b - - + + g diff --git a/docs/test_cases/t00055.md b/docs/test_cases/t00055.md index 2bda1960..59298184 100644 --- a/docs/test_cases/t00055.md +++ b/docs/test_cases/t00055.md @@ -246,7 +246,7 @@ struct J { }; } ], "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t00055_class.svg b/docs/test_cases/t00055_class.svg index a04ee22d..078af686 100644 --- a/docs/test_cases/t00055_class.svg +++ b/docs/test_cases/t00055_class.svg @@ -1,6 +1,6 @@ - + @@ -9,80 +9,80 @@ - - + + A - - + + B - - + + C - - + + D - - + + E - - + + F - - + + G - - + + H - - + + I - - + + J diff --git a/docs/test_cases/t00056.md b/docs/test_cases/t00056.md index 09e39397..14fd4657 100644 --- a/docs/test_cases/t00056.md +++ b/docs/test_cases/t00056.md @@ -559,7 +559,7 @@ struct F { } ], "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t00056_class.svg b/docs/test_cases/t00056_class.svg index 192e5d60..1c741a7e 100644 --- a/docs/test_cases/t00056_class.svg +++ b/docs/test_cases/t00056_class.svg @@ -1,6 +1,6 @@ - + @@ -9,8 +9,8 @@ - - + + «concept» @@ -20,8 +20,8 @@ - - + + «concept» @@ -33,8 +33,8 @@ sizeof (l) > sizeof (r) - - + + «concept» @@ -44,8 +44,8 @@ - - + + «concept» @@ -58,8 +58,8 @@ container.begin() container.end() - - + + «concept» @@ -71,8 +71,8 @@ typename T::value_type - - + + «concept» @@ -86,8 +86,8 @@ {std::to_string(s)} noexcept {std::to_string(s)} -> std::same_as<std::string> - - + + «concept» @@ -97,8 +97,8 @@ - - + + «concept» @@ -108,8 +108,8 @@ - - + + A @@ -118,15 +118,15 @@ - + - + a : T - - + + B @@ -135,15 +135,15 @@ - + - + b : T - - + + C @@ -152,15 +152,15 @@ - + - + c : T - - + + D @@ -169,8 +169,8 @@ - - + + E @@ -179,29 +179,29 @@ - + - + e1 : T1 - + - + e2 : T2 - + - + e3 : T3 - - + + F @@ -210,25 +210,25 @@ - + - + f1 : T1 - + - + f2 : T2 - + - + f3 : T3 diff --git a/docs/test_cases/t00057.md b/docs/test_cases/t00057.md index 63b965f7..a5cec4c2 100644 --- a/docs/test_cases/t00057.md +++ b/docs/test_cases/t00057.md @@ -488,7 +488,7 @@ struct t00057_R { } ], "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t00057_class.svg b/docs/test_cases/t00057_class.svg index 7fbc58f9..cd783b9d 100644 --- a/docs/test_cases/t00057_class.svg +++ b/docs/test_cases/t00057_class.svg @@ -1,6 +1,6 @@ - + @@ -9,53 +9,53 @@ - - + + t00057_A - + - + a1 : int - - + + t00057_B - + - + b1 : int - - + + t00057_C - + - + c1 : int - - + + «union» @@ -63,73 +63,73 @@ - + - + d1 : int - + - + d2 : float - - + + t00057_E - + - + coordinates : t00057_E::(anonymous_739) - + - + e : int - + - + height : t00057_E::(anonymous_807) - - + + t00057_E::(coordinates) - + - + x : int - + - + y : int - - + + «union» @@ -137,105 +137,105 @@ - + - + t : double - + - + z : int - - + + t00057_G - + - + g1 : int - - + + t00057_R - + - + a : struct t00057_A - + - + b : t00057_B - + - + c : struct t00057_C * - + - + d : union t00057_D - + - + e : struct t00057_E * - + - + f : struct t00057_F * - + - + g : struct t00057_G * - - + + t00057_F - + - + f1 : int diff --git a/docs/test_cases/t00058.md b/docs/test_cases/t00058.md index 7457dbb4..84999cd7 100644 --- a/docs/test_cases/t00058.md +++ b/docs/test_cases/t00058.md @@ -407,7 +407,7 @@ struct R { } ], "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t00058_class.svg b/docs/test_cases/t00058_class.svg index ec7351ad..11cd2d5f 100644 --- a/docs/test_cases/t00058_class.svg +++ b/docs/test_cases/t00058_class.svg @@ -1,6 +1,6 @@ - + @@ -9,8 +9,8 @@ - - + + first_type @@ -19,8 +19,8 @@ - - + + «concept» @@ -30,8 +30,8 @@ - - + + A @@ -40,15 +40,15 @@ - + - + a : std::vector<T> - - + + B @@ -57,22 +57,22 @@ - + - + b : std::vector<T> - + - + bb : P - - + + A @@ -81,8 +81,8 @@ - - + + A @@ -91,8 +91,8 @@ - - + + B @@ -101,26 +101,26 @@ - - + + R - + - + aa : A<int,int,double,std::string> - + - + bb : B<int,std::string,int,double,A<int,int>> diff --git a/docs/test_cases/t00059.md b/docs/test_cases/t00059.md index 167229ac..f80a0368 100644 --- a/docs/test_cases/t00059.md +++ b/docs/test_cases/t00059.md @@ -559,7 +559,7 @@ struct R { } ], "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t00059_class.svg b/docs/test_cases/t00059_class.svg index 9411e7b8..1884a829 100644 --- a/docs/test_cases/t00059_class.svg +++ b/docs/test_cases/t00059_class.svg @@ -1,6 +1,6 @@ - + @@ -9,8 +9,8 @@ - - + + «concept» @@ -23,8 +23,8 @@ T{} t.get_name() - - + + «concept» @@ -36,8 +36,8 @@ t.get_sweetness() - - + + «concept» @@ -49,8 +49,8 @@ t.get_bitterness() - - + + gala_apple @@ -61,8 +61,8 @@ get_sweetness() const : float - - + + empire_apple @@ -73,8 +73,8 @@ get_sweetness() const : float - - + + lima_orange @@ -85,8 +85,8 @@ get_name() const : std::string - - + + valencia_orange @@ -97,8 +97,8 @@ get_name() const : std::string - - + + fruit_factory @@ -111,8 +111,8 @@ create_orange() const : TO - - + + fruit_factory @@ -121,8 +121,8 @@ - - + + fruit_factory @@ -131,26 +131,26 @@ - - + + R - + - + factory_1 : fruit_factory_1 - + - + factory_2 : fruit_factory_2 diff --git a/docs/test_cases/t00060.md b/docs/test_cases/t00060.md index fd2a9397..47891094 100644 --- a/docs/test_cases/t00060.md +++ b/docs/test_cases/t00060.md @@ -256,7 +256,7 @@ template struct H : public G { } ], "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t00060_class.svg b/docs/test_cases/t00060_class.svg index 02a153c6..e408ab26 100644 --- a/docs/test_cases/t00060_class.svg +++ b/docs/test_cases/t00060_class.svg @@ -1,6 +1,6 @@ - + @@ -9,40 +9,40 @@ - - + + A - - + + B - - + + C - - + + D - - + + G @@ -51,15 +51,15 @@ - + - + g : T - - + + H @@ -68,18 +68,18 @@ - + - + h : G<T> - + - + hh : P diff --git a/docs/test_cases/t00061.md b/docs/test_cases/t00061.md index ae4946d4..0b032362 100644 --- a/docs/test_cases/t00061.md +++ b/docs/test_cases/t00061.md @@ -13,7 +13,7 @@ diagrams: namespaces: - clanguml::t00061 paths: - - include/t00061_a.h + - include/*_a.h using_namespace: - clanguml::t00061 ``` @@ -61,7 +61,7 @@ struct C { } ], "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t00061_class.svg b/docs/test_cases/t00061_class.svg index d91a05d1..8fa61952 100644 --- a/docs/test_cases/t00061_class.svg +++ b/docs/test_cases/t00061_class.svg @@ -1,6 +1,6 @@ - + @@ -9,8 +9,8 @@ - - + + A diff --git a/docs/test_cases/t00062.md b/docs/test_cases/t00062.md index d0f400d8..86de7ae7 100644 --- a/docs/test_cases/t00062.md +++ b/docs/test_cases/t00062.md @@ -1272,7 +1272,7 @@ struct A> { } ], "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t00062_class.svg b/docs/test_cases/t00062_class.svg index 517c08ae..51a655f9 100644 --- a/docs/test_cases/t00062_class.svg +++ b/docs/test_cases/t00062_class.svg @@ -1,6 +1,6 @@ - + @@ -9,8 +9,8 @@ - - + + A @@ -19,15 +19,15 @@ - + - + u : U & - - + + A @@ -36,15 +36,15 @@ - + - + u : U & - - + + A @@ -53,8 +53,8 @@ - - + + A @@ -63,15 +63,15 @@ - + - + u : U ** - - + + A @@ -80,15 +80,15 @@ - + - + u : U *** - - + + A @@ -97,15 +97,15 @@ - + - + u : U *** - - + + A @@ -114,15 +114,15 @@ - + - + u : U && - - + + A @@ -131,15 +131,15 @@ - + - + u : const U & - - + + A @@ -148,22 +148,22 @@ - + - + c : C & - + - + m : M C::* - - + + A @@ -172,22 +172,22 @@ - + - + c : C && - + - + m : M C::* - - + + A @@ -196,22 +196,22 @@ - + - + c : C & - + - + m : M C::* - - + + A @@ -220,15 +220,15 @@ - + - + c : C & - - + + A @@ -237,22 +237,22 @@ - + - + c : C && - + - + m : M C::* - - + + A @@ -261,22 +261,22 @@ - + - + c : C && - + - + mf : float C::* - - + + A @@ -285,22 +285,22 @@ - + - + c : C & - + - + m : M C::* - - + + A @@ -309,15 +309,15 @@ - + - + n : char[N] - - + + A @@ -326,15 +326,15 @@ - + - + n : std::vector<char> - - + + A @@ -343,15 +343,15 @@ - + - + klm : char[K][L][M] - - + + A @@ -360,15 +360,15 @@ - + - + u : bool - - + + A @@ -377,15 +377,15 @@ - + - + c : C<T> - - + + A @@ -394,22 +394,22 @@ - + - + args : std::tuple<Args...> - + - + c : C<T> - - + + A diff --git a/docs/test_cases/t00063.md b/docs/test_cases/t00063.md index f8af08c1..f23fb62f 100644 --- a/docs/test_cases/t00063.md +++ b/docs/test_cases/t00063.md @@ -59,7 +59,7 @@ enum class C { c1, c2, c3 }; } ], "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t00063_class.svg b/docs/test_cases/t00063_class.svg index c88e7cef..8c39cf2a 100644 --- a/docs/test_cases/t00063_class.svg +++ b/docs/test_cases/t00063_class.svg @@ -1,6 +1,6 @@ - + @@ -9,8 +9,8 @@ - - + + A diff --git a/docs/test_cases/t00064.md b/docs/test_cases/t00064.md index 5aa642e3..70a582bf 100644 --- a/docs/test_cases/t00064.md +++ b/docs/test_cases/t00064.md @@ -964,7 +964,7 @@ public: } ], "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t00064_class.svg b/docs/test_cases/t00064_class.svg index 689c2c2c..69e090ad 100644 --- a/docs/test_cases/t00064_class.svg +++ b/docs/test_cases/t00064_class.svg @@ -1,6 +1,6 @@ - + @@ -9,8 +9,8 @@ - - + + type_list @@ -19,8 +19,8 @@ - - + + type_list @@ -29,8 +29,8 @@ - - + + type_list @@ -39,8 +39,8 @@ - - + + type_list @@ -49,8 +49,8 @@ - - + + head @@ -59,8 +59,8 @@ - - + + type_list @@ -69,8 +69,8 @@ - - + + type_list @@ -79,8 +79,8 @@ - - + + type_list @@ -89,8 +89,8 @@ - - + + type_group_pair @@ -99,15 +99,15 @@ - + - + size : const size_t - - + + optional_ref @@ -116,8 +116,8 @@ - - + + optional_ref @@ -126,8 +126,8 @@ - - + + type_group_pair_it @@ -142,32 +142,32 @@ getp(unsigned int i) : value_type const* - - + + A - - + + B - - + + C - - + + type_list @@ -176,8 +176,8 @@ - - + + type_list @@ -186,8 +186,8 @@ - - + + type_list @@ -196,8 +196,8 @@ - - + + type_group_pair @@ -206,30 +206,30 @@ - - + + R - + - + abc : type_group_pair<type_list<float,double>,type_list<A,B,C>> - + - + aboolint : type_list<A,bool,int> - - + + type_group_pair @@ -238,8 +238,8 @@ - - + + type_group_pair_it @@ -248,8 +248,8 @@ - - + + head diff --git a/docs/test_cases/t00065.md b/docs/test_cases/t00065.md index 10adab44..59b05a0d 100644 --- a/docs/test_cases/t00065.md +++ b/docs/test_cases/t00065.md @@ -473,7 +473,7 @@ struct R { } ], "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t00065_class.svg b/docs/test_cases/t00065_class.svg index 7fdb8606..2c527296 100644 --- a/docs/test_cases/t00065_class.svg +++ b/docs/test_cases/t00065_class.svg @@ -1,6 +1,6 @@ - + @@ -9,20 +9,20 @@ - + module1 - + submodule1a - + module2 - + concepts - - + + ABC @@ -32,8 +32,8 @@ c - - + + XYZ @@ -43,45 +43,45 @@ z - - + + A - + - + abc : ABC - + - + pimpl : detail::AImpl * - + - + xyz : XYZ - - + + AImpl - - + + B @@ -93,8 +93,8 @@ b() : void - - + + C @@ -103,15 +103,15 @@ - + - + t : T * - - + + C @@ -120,8 +120,8 @@ - - + + D @@ -130,22 +130,22 @@ - + - + c : C<int> - + - + t : T - - + + C @@ -154,8 +154,8 @@ - - + + D @@ -164,8 +164,8 @@ - - + + «concept» @@ -176,33 +176,33 @@ T{} t.b() - - + + R - + - + a : A * - + - + c : C<B> - + - + d : D<B> diff --git a/docs/test_cases/t00066.md b/docs/test_cases/t00066.md index 9e606ba0..65c9ee18 100644 --- a/docs/test_cases/t00066.md +++ b/docs/test_cases/t00066.md @@ -660,7 +660,7 @@ int A::static_int = 1; } ], "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t00066_class.svg b/docs/test_cases/t00066_class.svg index cad28801..a6d3e3fa 100644 --- a/docs/test_cases/t00066_class.svg +++ b/docs/test_cases/t00066_class.svg @@ -1,6 +1,6 @@ - + @@ -9,74 +9,74 @@ - - + + A - + - + a_ : int - + - + auto_member : const unsigned long - + - + b_ : int - + - + c_ : int - + - + private_member : int - + - + protected_member : int - + - + public_member : int - + - + static_const_int : const int - + - + static_int : int @@ -120,11 +120,11 @@ sum(const double a, const double b) : int ~A() = default : void - + - + compare : std::function<bool (const int)> diff --git a/docs/test_cases/t00067.md b/docs/test_cases/t00067.md index c3bb7b42..0ea222eb 100644 --- a/docs/test_cases/t00067.md +++ b/docs/test_cases/t00067.md @@ -443,7 +443,7 @@ int A::static_int = 1; } ], "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t00067_class.svg b/docs/test_cases/t00067_class.svg index 3ceb58be..7b5ffcd9 100644 --- a/docs/test_cases/t00067_class.svg +++ b/docs/test_cases/t00067_class.svg @@ -1,6 +1,6 @@ - + @@ -9,8 +9,8 @@ - - + + A @@ -37,74 +37,74 @@ sum(const double a, const double b) : int - + - + a_ : int - + - + auto_member : const unsigned long - + - + b_ : int - + - + c_ : int - + - + compare : std::function<bool (const int)> - + - + private_member : int - + - + protected_member : int - + - + public_member : int - + - + static_const_int : const int - + - + static_int : int diff --git a/docs/test_cases/t20001.md b/docs/test_cases/t20001.md index 42c0c2dc..0db0e9d5 100644 --- a/docs/test_cases/t20001.md +++ b/docs/test_cases/t20001.md @@ -108,7 +108,7 @@ int tmain() { "diagram_type": "sequence", "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t20001_sequence.svg b/docs/test_cases/t20001_sequence.svg index 04e7ae85..ddf912c3 100644 --- a/docs/test_cases/t20001_sequence.svg +++ b/docs/test_cases/t20001_sequence.svg @@ -1,6 +1,6 @@ - + @@ -9,59 +9,59 @@ - - - - - - - + + + + + + + - - + + tmain() - + tmain() - - + + A - + A - - + + B - + B - - - - - - - - + + + + + + + + add(int,int) - + wrap_add3(int,int,int) - + add3(int,int,int) - + @@ -72,7 +72,7 @@ - + @@ -81,14 +81,14 @@ - + log_result(int) - + Main test function diff --git a/docs/test_cases/t20002.md b/docs/test_cases/t20002.md index ee0500f1..9ebd2a73 100644 --- a/docs/test_cases/t20002.md +++ b/docs/test_cases/t20002.md @@ -45,7 +45,7 @@ void m1() { m2(); } { "diagram_type": "sequence", "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t20002_sequence.svg b/docs/test_cases/t20002_sequence.svg index 670ba348..1e20e4b2 100644 --- a/docs/test_cases/t20002_sequence.svg +++ b/docs/test_cases/t20002_sequence.svg @@ -1,6 +1,6 @@ - + @@ -9,51 +9,51 @@ - - - - + + + + - - + + m1() - + m1() - - + + m2() - + m2() - - + + m3() - + m3() - - + + m4() - + m4() - - - - - + + + + + - + - + diff --git a/docs/test_cases/t20003.md b/docs/test_cases/t20003.md index d7af8423..2d5eef79 100644 --- a/docs/test_cases/t20003.md +++ b/docs/test_cases/t20003.md @@ -41,7 +41,7 @@ template void m1(T p) { m2(p); } { "diagram_type": "sequence", "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t20003_sequence.svg b/docs/test_cases/t20003_sequence.svg index e5a6350e..bb742d4d 100644 --- a/docs/test_cases/t20003_sequence.svg +++ b/docs/test_cases/t20003_sequence.svg @@ -1,6 +1,6 @@ - + @@ -9,51 +9,51 @@ - - - - + + + + - - + + m1<T>(T) - + m1<T>(T) - - + + m2<T>(T) - + m2<T>(T) - - + + m3<T>(T) - + m3<T>(T) - - + + m4<T>(T) - + m4<T>(T) - - - - - + + + + + - + - + diff --git a/docs/test_cases/t20004.md b/docs/test_cases/t20004.md index 76003e35..4f76a316 100644 --- a/docs/test_cases/t20004.md +++ b/docs/test_cases/t20004.md @@ -77,7 +77,7 @@ int main() { "diagram_type": "sequence", "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t20004_sequence.svg b/docs/test_cases/t20004_sequence.svg index fe661790..d3cbd3b2 100644 --- a/docs/test_cases/t20004_sequence.svg +++ b/docs/test_cases/t20004_sequence.svg @@ -1,6 +1,6 @@ - + @@ -9,16 +9,16 @@ - - - - - - - - - - + + + + + + + + + + @@ -29,87 +29,87 @@ - - + + main() - + main() - - + + m1<float>(float) - + m1<float>(float) - - + + m1<unsigned long>(unsigned long) - + m1<unsigned long>(unsigned long) - - + + m4<unsigned long>(unsigned long) - + m4<unsigned long>(unsigned long) - - + + m1<std::string>(std::string) - + m1<std::string>(std::string) - - + + m2<std::string>(std::string) - + m2<std::string>(std::string) - - + + m1<int>(int) - + m1<int>(int) - - + + m2<int>(int) - + m2<int>(int) - - + + m3<int>(int) - + m3<int>(int) - - + + m4<int>(int) - + m4<int>(int) - - - - - - - - - - - + + + + + + + + + + + - + - + @@ -117,11 +117,11 @@ - + - + @@ -129,19 +129,19 @@ - + - + - + - + diff --git a/docs/test_cases/t20005.md b/docs/test_cases/t20005.md index 0cab462f..b5f6e9de 100644 --- a/docs/test_cases/t20005.md +++ b/docs/test_cases/t20005.md @@ -48,7 +48,7 @@ template struct C { { "diagram_type": "sequence", "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t20005_sequence.svg b/docs/test_cases/t20005_sequence.svg index abbf680a..c9dbb4bd 100644 --- a/docs/test_cases/t20005_sequence.svg +++ b/docs/test_cases/t20005_sequence.svg @@ -1,6 +1,6 @@ - + @@ -9,42 +9,42 @@ - - - + + + - - + + C<T> - + C<T> - - + + B<T> - + B<T> - - + + A<T> - + A<T> - - - + + + c(T) - + b(T) - + a(T) diff --git a/docs/test_cases/t20006.md b/docs/test_cases/t20006.md index fac58d5f..19b4cd93 100644 --- a/docs/test_cases/t20006.md +++ b/docs/test_cases/t20006.md @@ -106,7 +106,7 @@ void tmain() { "diagram_type": "sequence", "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t20006_sequence.svg b/docs/test_cases/t20006_sequence.svg index e58917c5..d39f2282 100644 --- a/docs/test_cases/t20006_sequence.svg +++ b/docs/test_cases/t20006_sequence.svg @@ -1,6 +1,6 @@ - + @@ -9,22 +9,22 @@ - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + @@ -34,82 +34,82 @@ - - + + tmain() - + tmain() - - + + B<int> - + B<int> - - + + A<int> - + A<int> - - + + B<std::string> - + B<std::string> - - + + A<std::string> - + A<std::string> - - + + BB<int,int> - + BB<int,int> - - + + AA<int> - + AA<int> - - + + BB<int,std::string> - + BB<int,std::string> - - + + BB<int,float> - + BB<int,float> - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + b(int) - + a1(int) @@ -118,12 +118,12 @@ - + b(std::string) - + a2(std::string) @@ -132,59 +132,59 @@ - + bb1(int,int) - + aa1(int) - + bb2(int,int) - + aa2(int) - + bb1(int,std::string) - + aa2(int) - + bb2(int,std::string) - + aa1(int) - + bb1(int,float) - + bb2(int,float) - + aa2(int) diff --git a/docs/test_cases/t20007.md b/docs/test_cases/t20007.md index c07170e2..e94559f1 100644 --- a/docs/test_cases/t20007.md +++ b/docs/test_cases/t20007.md @@ -52,7 +52,7 @@ void tmain() { "diagram_type": "sequence", "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t20007_sequence.svg b/docs/test_cases/t20007_sequence.svg index ff5168ad..edbaba32 100644 --- a/docs/test_cases/t20007_sequence.svg +++ b/docs/test_cases/t20007_sequence.svg @@ -1,6 +1,6 @@ - + @@ -9,57 +9,57 @@ - - - - + + + + - - + + tmain() - + tmain() - - + + Adder<int,int> - + Adder<int,int> - - + + Adder<int,float,double> - + Adder<int,float,double> - - + + Adder<std::string,std::string,std::string> - + Adder<std::string,std::string,std::string> - - - - - + + + + + add(int &&,int &&) - + add(int &&,float &&,double &&) - + add(std::string &&,std::string &&,std::string &&) diff --git a/docs/test_cases/t20008.md b/docs/test_cases/t20008.md index c04d8784..cf272efb 100644 --- a/docs/test_cases/t20008.md +++ b/docs/test_cases/t20008.md @@ -70,7 +70,7 @@ void tmain() { "diagram_type": "sequence", "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t20008_sequence.svg b/docs/test_cases/t20008_sequence.svg index bafc051a..88276615 100644 --- a/docs/test_cases/t20008_sequence.svg +++ b/docs/test_cases/t20008_sequence.svg @@ -1,6 +1,6 @@ - + @@ -9,13 +9,13 @@ - - - - - - - + + + + + + + @@ -23,81 +23,81 @@ - - + + tmain() - + tmain() - - + + B<int> - + B<int> - - + + A<int> - + A<int> - - + + B<const char *> - + B<const char *> - - + + A<const char *> - + A<const char *> - - + + B<std::string> - + B<std::string> - - + + A<std::string> - + A<std::string> - - - - - - - - + + + + + + + + b(int) - + a1(int) - + b(const char *) - + a2(const char *) - + b(std::string) - + a3(std::string) diff --git a/docs/test_cases/t20009.md b/docs/test_cases/t20009.md index e196834e..24108663 100644 --- a/docs/test_cases/t20009.md +++ b/docs/test_cases/t20009.md @@ -56,7 +56,7 @@ void tmain() { "diagram_type": "sequence", "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t20009_sequence.svg b/docs/test_cases/t20009_sequence.svg index 29bb17f9..0d081f78 100644 --- a/docs/test_cases/t20009_sequence.svg +++ b/docs/test_cases/t20009_sequence.svg @@ -1,6 +1,6 @@ - + @@ -9,13 +9,13 @@ - - - - - - - + + + + + + + @@ -23,81 +23,81 @@ - - + + tmain() - + tmain() - - + + B<std::string> - + B<std::string> - - + + A<std::string> - + A<std::string> - - + + B<int> - + B<int> - - + + A<int> - + A<int> - - + + B<float> - + B<float> - - + + A<float> - + A<float> - - - - - - - - + + + + + + + + b(std::string) - + a(std::string) - + b(int) - + a(int) - + b(float) - + a(float) diff --git a/docs/test_cases/t20010.md b/docs/test_cases/t20010.md index ffc53bfa..e84c45cd 100644 --- a/docs/test_cases/t20010.md +++ b/docs/test_cases/t20010.md @@ -66,7 +66,7 @@ void tmain() { "diagram_type": "sequence", "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t20010_sequence.svg b/docs/test_cases/t20010_sequence.svg index 7996747f..dd7e4e4b 100644 --- a/docs/test_cases/t20010_sequence.svg +++ b/docs/test_cases/t20010_sequence.svg @@ -1,6 +1,6 @@ - + @@ -9,81 +9,81 @@ - - - - - - - - - + + + + + + + + + - - + + tmain() - + tmain() - - + + B<int> - + B<int> - - + + A - + A - - - - - - - - - - + + + + + + + + + + b1() - + a1() - + b2() - + a2() - + b3() - + a3() - + b4() - + a4() diff --git a/docs/test_cases/t20011.md b/docs/test_cases/t20011.md index 08b02de5..6dcc3fc2 100644 --- a/docs/test_cases/t20011.md +++ b/docs/test_cases/t20011.md @@ -58,7 +58,7 @@ void tmain() { "diagram_type": "sequence", "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t20011_sequence.svg b/docs/test_cases/t20011_sequence.svg index d16df17a..4ba91655 100644 --- a/docs/test_cases/t20011_sequence.svg +++ b/docs/test_cases/t20011_sequence.svg @@ -1,6 +1,6 @@ - + @@ -9,42 +9,42 @@ - - - - - - - - - - - - + + + + + + + + + + + + - - + + tmain() - + tmain() - - + + A - + A - - - - - - - - - - + + + + + + + + + + a(int) @@ -52,26 +52,26 @@ alt - + a(int) - + b(int) - + c(int) - + @@ -81,14 +81,14 @@ alt - + b(int) - + @@ -98,7 +98,7 @@ alt - + diff --git a/docs/test_cases/t20012.md b/docs/test_cases/t20012.md index 4bf3e5d2..8cc47714 100644 --- a/docs/test_cases/t20012.md +++ b/docs/test_cases/t20012.md @@ -133,7 +133,7 @@ void tmain() { "diagram_type": "sequence", "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t20012_sequence.svg b/docs/test_cases/t20012_sequence.svg index af4e067f..9c6067ec 100644 --- a/docs/test_cases/t20012_sequence.svg +++ b/docs/test_cases/t20012_sequence.svg @@ -1,6 +1,6 @@ - + @@ -9,31 +9,31 @@ - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + @@ -43,122 +43,122 @@ - - + + tmain() - + tmain() - - + + tmain()::(lambda ../../tests/t20012/t20012.cc:67:20) - + tmain()::(lambda ../../tests/t20012/t20012.cc:67:20) - - + + A - + A - - + + B - + B - - + + tmain()::(lambda ../../tests/t20012/t20012.cc:80:20) - + tmain()::(lambda ../../tests/t20012/t20012.cc:80:20) - - + + C - + C - - + + R<R::(lambda ../../tests/t20012/t20012.cc:86:9)> - + R<R::(lambda ../../tests/t20012/t20012.cc:86:9)> - - + + tmain()::(lambda ../../tests/t20012/t20012.cc:86:9) - + tmain()::(lambda ../../tests/t20012/t20012.cc:86:9) - - + + D - + D - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + operator()() - + a() - + aa() - + aaa() - + b() - + bb() - + @@ -167,67 +167,67 @@ - + operator()() - + c() - + cc() - + ccc() - + operator()() - + a() - + aa() - + aaa() - + b() - + bb() - + @@ -238,29 +238,29 @@ - + r() - + operator()() - + c() - + cc() - + @@ -269,7 +269,7 @@ - + add5(int) diff --git a/docs/test_cases/t20013.md b/docs/test_cases/t20013.md index 922d5d15..24774244 100644 --- a/docs/test_cases/t20013.md +++ b/docs/test_cases/t20013.md @@ -54,7 +54,7 @@ void tmain(int argc, char **argv) { "diagram_type": "sequence", "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t20013_sequence.svg b/docs/test_cases/t20013_sequence.svg index 7beb1d34..b0110a22 100644 --- a/docs/test_cases/t20013_sequence.svg +++ b/docs/test_cases/t20013_sequence.svg @@ -1,6 +1,6 @@ - + @@ -9,47 +9,47 @@ - - - - - - - + + + + + + + - - + + tmain(int,char **) - + tmain(int,char **) - - + + B - + B - - + + A - + A - - - - - - - - + + + + + + + + b(int) - + a1(int) @@ -58,12 +58,12 @@ - + b(double) - + a2(double) @@ -72,12 +72,12 @@ - + b(const char *) - + a3(const char *) diff --git a/docs/test_cases/t20014.md b/docs/test_cases/t20014.md index 4843ccf6..cb5e58b9 100644 --- a/docs/test_cases/t20014.md +++ b/docs/test_cases/t20014.md @@ -89,7 +89,7 @@ namespace t20014 { { "diagram_type": "sequence", "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t20014_sequence.svg b/docs/test_cases/t20014_sequence.svg index 0e71535a..49cbc40b 100644 --- a/docs/test_cases/t20014_sequence.svg +++ b/docs/test_cases/t20014_sequence.svg @@ -1,6 +1,6 @@ - + @@ -9,56 +9,56 @@ - - - - - - - - + + + + + + + + - - + + tmain() - + tmain() - - + + B - + B - - + + A - + A - - + + C<B,int> - + C<B,int> - - - - - - - - - + + + + + + + + + b1(int,int) - + a1(int,int) @@ -67,12 +67,12 @@ - + b2(int,int) - + a2(int,int) @@ -81,17 +81,17 @@ - + c1(int,int) - + b1(int,int) - + a1(int,int) diff --git a/docs/test_cases/t20015.md b/docs/test_cases/t20015.md index 5fb8a842..53073d2c 100644 --- a/docs/test_cases/t20015.md +++ b/docs/test_cases/t20015.md @@ -70,7 +70,7 @@ void tmain() { "diagram_type": "sequence", "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t20015_sequence.svg b/docs/test_cases/t20015_sequence.svg index 5f3f708d..e3020780 100644 --- a/docs/test_cases/t20015_sequence.svg +++ b/docs/test_cases/t20015_sequence.svg @@ -1,6 +1,6 @@ - + @@ -9,25 +9,25 @@ - - + + - - + + tmain() - + tmain() - - + + B - + B - - - + + + setup_a(std::shared_ptr<detail::A> &) diff --git a/docs/test_cases/t20016.md b/docs/test_cases/t20016.md index ffcc5de4..4ccbe3bb 100644 --- a/docs/test_cases/t20016.md +++ b/docs/test_cases/t20016.md @@ -52,7 +52,7 @@ void tmain() { "diagram_type": "sequence", "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t20016_sequence.svg b/docs/test_cases/t20016_sequence.svg index 368dd5e6..3308ee71 100644 --- a/docs/test_cases/t20016_sequence.svg +++ b/docs/test_cases/t20016_sequence.svg @@ -1,6 +1,6 @@ - + @@ -9,53 +9,53 @@ - - - - - + + + + + - - + + tmain() - + tmain() - - + + B<long> - + B<long> - - + + A - + A - - - - - - + + + + + + b1(long) - + a1(int) - + b2(long) - + a2(const long &) diff --git a/docs/test_cases/t20017.md b/docs/test_cases/t20017.md index 8f58260b..0415d8dc 100644 --- a/docs/test_cases/t20017.md +++ b/docs/test_cases/t20017.md @@ -49,7 +49,7 @@ int tmain() { return b2(a1(a2(a3(1, 2), b1(3, 4)), 5), 6); } { "diagram_type": "sequence", "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t20017_sequence.svg b/docs/test_cases/t20017_sequence.svg index 32d144b5..732af4b6 100644 --- a/docs/test_cases/t20017_sequence.svg +++ b/docs/test_cases/t20017_sequence.svg @@ -1,6 +1,6 @@ - + @@ -9,65 +9,65 @@ - - - - - - + + + + + + - + t20017.cc - + t20017.cc - + include/t20017_a.h - + include/t20017_a.h - + include/t20017_b.h - + include/t20017_b.h - - - - - - + + + + + + tmain() - + a3(int,int) - + b1(int,int) - + a2(int,int) - + a1(int,int) - + b2<int>(int,int) diff --git a/docs/test_cases/t20018.md b/docs/test_cases/t20018.md index 072b0912..c1de4cfa 100644 --- a/docs/test_cases/t20018.md +++ b/docs/test_cases/t20018.md @@ -54,7 +54,7 @@ void tmain() { Answer>::print(); } { "diagram_type": "sequence", "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t20018_sequence.svg b/docs/test_cases/t20018_sequence.svg index 128e973f..3b12fd51 100644 --- a/docs/test_cases/t20018_sequence.svg +++ b/docs/test_cases/t20018_sequence.svg @@ -1,6 +1,6 @@ - + @@ -9,14 +9,14 @@ - - - - - - - - + + + + + + + + @@ -25,93 +25,93 @@ - - + + tmain() - + tmain() - - + + Answer<Factorial<5>,120> - + Answer<Factorial<5>,120> - - + + Factorial<5> - + Factorial<5> - - + + Factorial<4> - + Factorial<4> - - + + Factorial<3> - + Factorial<3> - - + + Factorial<2> - + Factorial<2> - - + + Factorial<1> - + Factorial<1> - - + + Factorial<0> - + Factorial<0> - - - - - - - - - + + + + + + + + + print() - + print(int) - + print(int) - + print(int) - + print(int) - + print(int) - + print(int) diff --git a/docs/test_cases/t20019.md b/docs/test_cases/t20019.md index 9246707e..e0d63989 100644 --- a/docs/test_cases/t20019.md +++ b/docs/test_cases/t20019.md @@ -61,7 +61,7 @@ void tmain() { "diagram_type": "sequence", "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t20019_sequence.svg b/docs/test_cases/t20019_sequence.svg index 4079b70c..89061afb 100644 --- a/docs/test_cases/t20019_sequence.svg +++ b/docs/test_cases/t20019_sequence.svg @@ -1,6 +1,6 @@ - + @@ -9,95 +9,95 @@ - - - - - - - - - + + + + + + + + + - - + + tmain() - + tmain() - - + + Base<D1> - + Base<D1> - - + + D1 - + D1 - - + + Base<D2> - + Base<D2> - - + + D2 - + D2 - - - - - - - - - - + + + + + + + + + + name() - + impl() - + name() - + impl() - + name() - + impl() - + name() - + impl() diff --git a/docs/test_cases/t20020.md b/docs/test_cases/t20020.md index 7ab3223f..2bda9fb7 100644 --- a/docs/test_cases/t20020.md +++ b/docs/test_cases/t20020.md @@ -113,7 +113,7 @@ int tmain() { "diagram_type": "sequence", "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t20020_sequence.svg b/docs/test_cases/t20020_sequence.svg index 6c958712..ca805431 100644 --- a/docs/test_cases/t20020_sequence.svg +++ b/docs/test_cases/t20020_sequence.svg @@ -1,6 +1,6 @@ - + @@ -9,78 +9,78 @@ - - - - - - - - - - - - - - + + + + + + + + + + + + + + - + - - - + + + - - + + tmain() - + tmain() - - + + A - + A - - + + C - + C - - + + B - + B - - + + D<int> - + D<int> - - - - - - - - - - - - - + + + + + + + + + + + + + alt - + a1() @@ -91,7 +91,7 @@ alt - + [ @@ -100,7 +100,7 @@ - + [ @@ -109,7 +109,7 @@ - + b1() @@ -117,7 +117,7 @@ - + [ @@ -126,21 +126,21 @@ - + b2() - + a4() - + log() @@ -148,7 +148,7 @@ alt - + c1() @@ -156,7 +156,7 @@ alt - + @@ -169,7 +169,7 @@ - + @@ -179,7 +179,7 @@ alt - + d1(int,int) diff --git a/docs/test_cases/t20021.md b/docs/test_cases/t20021.md index 5ebf091d..b4cb76da 100644 --- a/docs/test_cases/t20021.md +++ b/docs/test_cases/t20021.md @@ -84,7 +84,7 @@ int tmain() { "diagram_type": "sequence", "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t20021_sequence.svg b/docs/test_cases/t20021_sequence.svg index 95733f13..2ed510c2 100644 --- a/docs/test_cases/t20021_sequence.svg +++ b/docs/test_cases/t20021_sequence.svg @@ -1,6 +1,6 @@ - + @@ -9,74 +9,74 @@ - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + - - + + tmain() - + tmain() - - + + C - + C - - + + A - + A - - + + B - + B - - - - - - - - - - - - + + + + + + + + + + + + loop - + [ c4() ] - + @@ -89,7 +89,7 @@ - + a3() @@ -102,7 +102,7 @@ loop - + [ @@ -111,7 +111,7 @@ - + [ @@ -120,7 +120,7 @@ - + [ @@ -129,14 +129,14 @@ - + a1() - + [ @@ -148,7 +148,7 @@ loop - + b2() @@ -158,7 +158,7 @@ loop - + [ @@ -167,7 +167,7 @@ - + b2() diff --git a/docs/test_cases/t20022.md b/docs/test_cases/t20022.md index 64c1d500..c8c976ef 100644 --- a/docs/test_cases/t20022.md +++ b/docs/test_cases/t20022.md @@ -64,7 +64,7 @@ int tmain() { "diagram_type": "sequence", "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t20022_sequence.svg b/docs/test_cases/t20022_sequence.svg index 737ee50b..89b50d31 100644 --- a/docs/test_cases/t20022_sequence.svg +++ b/docs/test_cases/t20022_sequence.svg @@ -1,6 +1,6 @@ - + @@ -9,39 +9,39 @@ - - - + + + - - + + tmain() - + tmain() - - + + A - + A - - + + B - + B - - - - + + + + a() - + b() diff --git a/docs/test_cases/t20023.md b/docs/test_cases/t20023.md index ae6063af..cb5510af 100644 --- a/docs/test_cases/t20023.md +++ b/docs/test_cases/t20023.md @@ -67,7 +67,7 @@ int tmain() { "diagram_type": "sequence", "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t20023_sequence.svg b/docs/test_cases/t20023_sequence.svg index 49c29075..94c0a341 100644 --- a/docs/test_cases/t20023_sequence.svg +++ b/docs/test_cases/t20023_sequence.svg @@ -1,6 +1,6 @@ - + @@ -9,37 +9,37 @@ - - - - - - - + + + + + + + - - + + tmain() - + tmain() - - + + A - + A - - - - - - - + + + + + + + a() @@ -47,7 +47,7 @@ try - + @@ -60,7 +60,7 @@ [std::runtime_error &] - + @@ -73,7 +73,7 @@ [std::logic_error &] - + @@ -86,7 +86,7 @@ [...] - + diff --git a/docs/test_cases/t20024.md b/docs/test_cases/t20024.md index 6f50ca24..91cc23c2 100644 --- a/docs/test_cases/t20024.md +++ b/docs/test_cases/t20024.md @@ -92,7 +92,7 @@ int tmain() { "diagram_type": "sequence", "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t20024_sequence.svg b/docs/test_cases/t20024_sequence.svg index fed502e9..ac70ba93 100644 --- a/docs/test_cases/t20024_sequence.svg +++ b/docs/test_cases/t20024_sequence.svg @@ -1,6 +1,6 @@ - + @@ -9,23 +9,23 @@ - - - - - - - - - - - - + + + + + + + + + + + + - + @@ -33,36 +33,36 @@ - - + + tmain() - + tmain() - - + + A - + A - - + + B - + B - - - - - - - - - - - - + + + + + + + + + + + + select(enum_a) @@ -72,7 +72,7 @@ switch [zero] - + @@ -85,7 +85,7 @@ [one] - + @@ -98,7 +98,7 @@ [two] - + @@ -111,7 +111,7 @@ [default] - + @@ -124,7 +124,7 @@ - + select(colors) @@ -134,7 +134,7 @@ switch [enum colors::red] - + @@ -143,7 +143,7 @@ [enum colors::orange] - + @@ -152,7 +152,7 @@ [enum colors::green] - + @@ -161,7 +161,7 @@ [default] - + diff --git a/docs/test_cases/t20025.md b/docs/test_cases/t20025.md index 6e79758a..427aea84 100644 --- a/docs/test_cases/t20025.md +++ b/docs/test_cases/t20025.md @@ -72,7 +72,7 @@ int tmain() { "diagram_type": "sequence", "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t20025_sequence.svg b/docs/test_cases/t20025_sequence.svg index d85025e3..427add9c 100644 --- a/docs/test_cases/t20025_sequence.svg +++ b/docs/test_cases/t20025_sequence.svg @@ -1,6 +1,6 @@ - + @@ -9,41 +9,41 @@ - - - - + + + + - - + + tmain() - + tmain() - - + + A - + A - - + + add(int,int) - + add(int,int) - - - - - + + + + + a() - + @@ -52,7 +52,7 @@ - + diff --git a/docs/test_cases/t20026.md b/docs/test_cases/t20026.md index 7fe3e904..00bdd64b 100644 --- a/docs/test_cases/t20026.md +++ b/docs/test_cases/t20026.md @@ -52,7 +52,7 @@ int tmain() { "diagram_type": "sequence", "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t20026_sequence.svg b/docs/test_cases/t20026_sequence.svg index b7e63316..c00c49f5 100644 --- a/docs/test_cases/t20026_sequence.svg +++ b/docs/test_cases/t20026_sequence.svg @@ -1,6 +1,6 @@ - + @@ -9,25 +9,25 @@ - - + + - - + + tmain() - + tmain() - - + + A - + A - - - + + + a() diff --git a/docs/test_cases/t20027.md b/docs/test_cases/t20027.md index e9633509..193e7cb7 100644 --- a/docs/test_cases/t20027.md +++ b/docs/test_cases/t20027.md @@ -51,7 +51,7 @@ void tmain() { "diagram_type": "sequence", "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t20027_sequence.svg b/docs/test_cases/t20027_sequence.svg index 8b62b682..c47c3dae 100644 --- a/docs/test_cases/t20027_sequence.svg +++ b/docs/test_cases/t20027_sequence.svg @@ -1,6 +1,6 @@ - + @@ -9,25 +9,25 @@ - - + + - - + + tmain() - + tmain() - - + + A - + A - - - + + + a() diff --git a/docs/test_cases/t20028.md b/docs/test_cases/t20028.md index 610685a1..165d7a77 100644 --- a/docs/test_cases/t20028.md +++ b/docs/test_cases/t20028.md @@ -61,7 +61,7 @@ int tmain() { "diagram_type": "sequence", "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t20028_sequence.svg b/docs/test_cases/t20028_sequence.svg index 87a14f0e..c1835714 100644 --- a/docs/test_cases/t20028_sequence.svg +++ b/docs/test_cases/t20028_sequence.svg @@ -1,6 +1,6 @@ - + @@ -9,50 +9,50 @@ - - - - - - + + + + + + - - + + tmain() - + tmain() - - + + A - + A - - - - - + + + + + alt - + a() - + b() - + c() @@ -60,7 +60,7 @@ - + d() diff --git a/docs/test_cases/t20029.md b/docs/test_cases/t20029.md index e9595240..cf307fd8 100644 --- a/docs/test_cases/t20029.md +++ b/docs/test_cases/t20029.md @@ -105,7 +105,7 @@ int tmain() { "diagram_type": "sequence", "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t20029_sequence.svg b/docs/test_cases/t20029_sequence.svg index 6ad19b75..d39ab578 100644 --- a/docs/test_cases/t20029_sequence.svg +++ b/docs/test_cases/t20029_sequence.svg @@ -1,6 +1,6 @@ - + @@ -9,60 +9,60 @@ - - - - - - - - - - - + + + + + + + + + + + - - + + tmain() - + tmain() - - + + Encoder<Retrier<ConnectionPool>> - + Encoder<Retrier<ConnectionPool>> - - + + Retrier<ConnectionPool> - + Retrier<ConnectionPool> - - + + ConnectionPool - + ConnectionPool - - + + encode_b64(std::string &&) - + encode_b64(std::string &&) - - - - - - - - + + + + + + + + connect() @@ -73,21 +73,21 @@ alt - + [ send(std::string &&) ] - + encode(std::string &&) - + @@ -97,7 +97,7 @@ - + send(std::string &&) @@ -108,7 +108,7 @@ alt - + [ diff --git a/docs/test_cases/t30001.md b/docs/test_cases/t30001.md index ad04cb83..3d3c4b63 100644 --- a/docs/test_cases/t30001.md +++ b/docs/test_cases/t30001.md @@ -191,7 +191,7 @@ namespace BB { } ], "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t30001_package.svg b/docs/test_cases/t30001_package.svg index 571dced3..228fff70 100644 --- a/docs/test_cases/t30001_package.svg +++ b/docs/test_cases/t30001_package.svg @@ -1,6 +1,6 @@ - + @@ -9,63 +9,63 @@ - - + + A - - + + AA - - + + B - - + + AA - - + + AAA - - + + BBB - - + + BB - - + + AAA - - + + BBB - - + + BB - + A AAA note... - + This is namespace AA in namespace A - + This is namespace AA in namespace B diff --git a/docs/test_cases/t30002.md b/docs/test_cases/t30002.md index ae235a47..8efa665b 100644 --- a/docs/test_cases/t30002.md +++ b/docs/test_cases/t30002.md @@ -413,7 +413,7 @@ template std::map> cm() } ], "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t30002_package.svg b/docs/test_cases/t30002_package.svg index f1f4aafd..e6e6e903 100644 --- a/docs/test_cases/t30002_package.svg +++ b/docs/test_cases/t30002_package.svg @@ -1,6 +1,6 @@ - + @@ -9,118 +9,118 @@ - - + + A - - + + AA - - + + B - - + + BB - - + + A1 - - + + A2 - - + + A3 - - + + A4 - - + + A5 - - + + A6 - - + + A7 - - + + A8 - - + + A9 - - + + A10 - - + + A11 - - + + A12 - - + + A13 - - + + A14 - - + + A15 - - + + A16 - - + + A17 - - + + A18 - - + + BBB diff --git a/docs/test_cases/t30003.md b/docs/test_cases/t30003.md index afabb8ff..8214c47c 100644 --- a/docs/test_cases/t30003.md +++ b/docs/test_cases/t30003.md @@ -129,7 +129,7 @@ class B : public ns1::ns2::Anon { }; } ], "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t30003_package.svg b/docs/test_cases/t30003_package.svg index a94afdcf..8a6b480d 100644 --- a/docs/test_cases/t30003_package.svg +++ b/docs/test_cases/t30003_package.svg @@ -1,6 +1,6 @@ - + @@ -9,35 +9,35 @@ - - + + ns1 - - + + ns3 «deprecated» - - + + ns1 - - + + ns2_v1_0_0 - - + + ns2_v0_9_0 «deprecated» - - + + ns2 diff --git a/docs/test_cases/t30004.md b/docs/test_cases/t30004.md index 66db1a16..e1601be8 100644 --- a/docs/test_cases/t30004.md +++ b/docs/test_cases/t30004.md @@ -142,7 +142,7 @@ namespace CCC { } ], "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t30004_package.svg b/docs/test_cases/t30004_package.svg index 695ad964..6473bc79 100644 --- a/docs/test_cases/t30004_package.svg +++ b/docs/test_cases/t30004_package.svg @@ -1,6 +1,6 @@ - + @@ -9,40 +9,40 @@ - - + + A - + Package AAA. - + Package BBB. - + CCCC package note. - + We skipped DDD. - - + + AAA - - + + BBB - - + + CCC - - + + EEE diff --git a/docs/test_cases/t30005.md b/docs/test_cases/t30005.md index 9853ef8d..de60c068 100644 --- a/docs/test_cases/t30005.md +++ b/docs/test_cases/t30005.md @@ -168,7 +168,7 @@ struct C2 { } ], "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t30005_package.svg b/docs/test_cases/t30005_package.svg index 08d81236..23a90b6d 100644 --- a/docs/test_cases/t30005_package.svg +++ b/docs/test_cases/t30005_package.svg @@ -1,6 +1,6 @@ - + @@ -9,48 +9,48 @@ - - + + A - - + + AA - - + + B - - + + BB - - + + C - - + + CC - - + + AAA - - + + BBB - - + + CCC diff --git a/docs/test_cases/t30006.md b/docs/test_cases/t30006.md index 6f651137..ae117700 100644 --- a/docs/test_cases/t30006.md +++ b/docs/test_cases/t30006.md @@ -94,7 +94,7 @@ struct A2 { } ], "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t30006_package.svg b/docs/test_cases/t30006_package.svg index b4127846..31903fbb 100644 --- a/docs/test_cases/t30006_package.svg +++ b/docs/test_cases/t30006_package.svg @@ -1,6 +1,6 @@ - + @@ -9,22 +9,22 @@ - - + + B - - + + A - - + + C - + Top A note. diff --git a/docs/test_cases/t30007.md b/docs/test_cases/t30007.md index 2df303e6..b72e1056 100644 --- a/docs/test_cases/t30007.md +++ b/docs/test_cases/t30007.md @@ -115,7 +115,7 @@ struct A2 { } ], "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t30007_package.svg b/docs/test_cases/t30007_package.svg index 9c7f008c..baaff1f7 100644 --- a/docs/test_cases/t30007_package.svg +++ b/docs/test_cases/t30007_package.svg @@ -1,6 +1,6 @@ - + @@ -9,27 +9,27 @@ - - + + A - - + + B - - + + AA - - + + C - + Compare layout with t30006. diff --git a/docs/test_cases/t30008.md b/docs/test_cases/t30008.md index 50948921..cc472ab8 100644 --- a/docs/test_cases/t30008.md +++ b/docs/test_cases/t30008.md @@ -191,7 +191,7 @@ struct FF { } ], "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t30008_package.svg b/docs/test_cases/t30008_package.svg index ab6a178e..55813fb6 100644 --- a/docs/test_cases/t30008_package.svg +++ b/docs/test_cases/t30008_package.svg @@ -1,6 +1,6 @@ - + @@ -9,43 +9,43 @@ - - + + dependants - - + + dependencies - - + + A - - + + B - - + + C - - + + D - - + + E - - + + F diff --git a/docs/test_cases/t30009.md b/docs/test_cases/t30009.md index a893e666..579eab5b 100644 --- a/docs/test_cases/t30009.md +++ b/docs/test_cases/t30009.md @@ -169,7 +169,7 @@ namespace D { } ], "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t30009_package.svg b/docs/test_cases/t30009_package.svg index de51fcd3..6eae9dac 100644 --- a/docs/test_cases/t30009_package.svg +++ b/docs/test_cases/t30009_package.svg @@ -1,6 +1,6 @@ - + @@ -9,53 +9,53 @@ - - + + One - - + + Two - - + + B - - + + D - - + + A - - + + C - - + + A - - + + B - - + + C - - + + D diff --git a/docs/test_cases/t30010.md b/docs/test_cases/t30010.md index 1865545c..405d1f27 100644 --- a/docs/test_cases/t30010.md +++ b/docs/test_cases/t30010.md @@ -86,7 +86,7 @@ App app; } ], "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t30011.md b/docs/test_cases/t30011.md index 44c63344..71ac4d84 100644 --- a/docs/test_cases/t30011.md +++ b/docs/test_cases/t30011.md @@ -75,7 +75,7 @@ struct t30011_App app; } ], "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t40001.md b/docs/test_cases/t40001.md index 7921d30a..305dcbba 100644 --- a/docs/test_cases/t40001.md +++ b/docs/test_cases/t40001.md @@ -101,7 +101,7 @@ diagrams: } ], "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t40001_include.svg b/docs/test_cases/t40001_include.svg index 1ee73159..c3efd958 100644 --- a/docs/test_cases/t40001_include.svg +++ b/docs/test_cases/t40001_include.svg @@ -1,6 +1,6 @@ - + @@ -9,43 +9,43 @@ - + src - + include - + lib1 - - + + t40001.cc - - + + t40001_include1.h - - + + lib1.h - + string - + vector - + yaml-cpp/yaml.h - + This is a lib1 include dir - + This is a t40001_include1.h include file diff --git a/docs/test_cases/t40002.md b/docs/test_cases/t40002.md index 338b104a..0c5d9dd1 100644 --- a/docs/test_cases/t40002.md +++ b/docs/test_cases/t40002.md @@ -119,7 +119,7 @@ diagrams: } ], "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t40002_include.svg b/docs/test_cases/t40002_include.svg index e4eab262..5dadd03a 100644 --- a/docs/test_cases/t40002_include.svg +++ b/docs/test_cases/t40002_include.svg @@ -1,6 +1,6 @@ - + @@ -9,46 +9,46 @@ - + src - + lib1 - + lib2 - + include - + lib1 - + lib2 - - + + t40002.cc - - + + lib1.cc - - + + lib2.cc - - + + lib1.h - - + + lib2.h diff --git a/docs/test_cases/t40003.md b/docs/test_cases/t40003.md index 0c74e46f..e4239d04 100644 --- a/docs/test_cases/t40003.md +++ b/docs/test_cases/t40003.md @@ -145,7 +145,7 @@ diagrams: } ], "metadata": { - "clang_uml_version": "0.3.6-11-g75d1daa", + "clang_uml_version": "0.3.6-31-g01ef3dc", "llvm_version": "Ubuntu clang version 15.0.6", "schema_version": 1 }, diff --git a/docs/test_cases/t40003_include.svg b/docs/test_cases/t40003_include.svg index a1d85429..9c609eca 100644 --- a/docs/test_cases/t40003_include.svg +++ b/docs/test_cases/t40003_include.svg @@ -1,6 +1,6 @@ - + @@ -9,66 +9,66 @@ - + src - + dependants - + dependencies - + include - + dependants - + dependencies - - + + t1.cc - - + + t2.cc - - + + t3.h - - + + t2.h - - + + t1.h - - + + t3.h - - + + t2.h - - + + t1.h - - + + t5.h From 6d329dfdf6fcec4507723f9119085ff47b64fc24 Mon Sep 17 00:00:00 2001 From: Bartek Kryza Date: Sat, 10 Jun 2023 19:36:07 +0200 Subject: [PATCH 15/15] Fixed diagram filters docs --- docs/diagram_filters.md | 25 +++++++++++++------------ 1 file changed, 13 insertions(+), 12 deletions(-) diff --git a/docs/diagram_filters.md b/docs/diagram_filters.md index b42bb74c..0fb896b7 100644 --- a/docs/diagram_filters.md +++ b/docs/diagram_filters.md @@ -40,7 +40,7 @@ Some filters accept either specified exact values, some support regular expressions while some except glob patterns. For filters which accept regular expressions, the regular expression has to -be provided as a map `re: 'pattern'` due to the fact the pointer (`*`) otherwise +be provided as a map `r: 'pattern'` due to the fact the pointer (`*`) otherwise would have to be escaped in situations such as `mycontainer`, so for instance to specify that the diagram should exclude all classes containing the word `test` simply add the following filter: @@ -48,7 +48,7 @@ word `test` simply add the following filter: ```yaml exclude: elements: - - re: '.*test.*' + - r: '.*test.*' ``` `paths` filter is currently the only filter which accepts `glob` like patterns. @@ -57,18 +57,19 @@ The following table specifies the values allowed in each filter: | Filter name | Possible values | Example values | |-------------------|----------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------| -| `namespaces` | Qualified name or regex | - `ns1::ns2::ClassA`
- `re: '.\*detail.\*'` | -| `elements` | Qualified name or regex | - `ns1::ns2::ClassA`
- `re: '.\*detail.\*'` | +| `namespaces` | Qualified name or regex | - `ns1::ns2::ClassA`
- `r: '.*detail.*'` | +| `elements` | Qualified name or regex | - `ns1::ns2::ClassA`
- `r: '.*detail.*'` | +| `element_types` | Types of diagram elements | - `class`
- `enum`
- `concept` | | `paths` | File or dir path or glob pattern | - `src/dir1`
- `src/dir2/a.cpp`
- `src/dir3/*.cpp` | -| `context` | Qualified name or regex | - `ns1::ns2::ClassA`
- `re: 'ns1::ns2::ClassA.+'` | +| `context` | Qualified name or regex | - `ns1::ns2::ClassA`
- `r: 'ns1::ns2::ClassA.+'` | | `relationships` | Type of relationship | - `inheritance`
- `composition`
- `aggregation`
- `ownership`
- `association`
- `instantiation`
- `friendship`
- `dependency` | -| `subclasses` | Qualified name or regex | - `ns1::ns2::ClassA`
- `re: 'ns1::ns2::ClassA.+'` | -| `parents` | Qualified name or regex | - `ns1::ns2::ClassA`
- `re: 'ns1::ns2::ClassA.+'` | -| `specializations` | Qualified name or regex | - `ns1::ns2::ClassA`
- `re: 'ns1::ns2::ClassA.+'` | +| `subclasses` | Qualified name or regex | - `ns1::ns2::ClassA`
- `r: 'ns1::ns2::ClassA.+'` | +| `parents` | Qualified name or regex | - `ns1::ns2::ClassA`
- `r: 'ns1::ns2::ClassA.+'` | +| `specializations` | Qualified name or regex | - `ns1::ns2::ClassA`
- `r: 'ns1::ns2::ClassA.+'` | | `access` | Method or member access scope | - `public`
- `protected`
- `private` | | `method_types` | Type of class method | - `constructor`
- `destructor`
- `assignment`
- `operator`
- `defaulted`
- `deleted`
- `static` | -| `dependants` | Qualified name or regex | - `ns1::ns2::ClassA`
- `re: 'ns1::ns2::ClassA.+'` | -| `dependencies` | Qualified name or regex | - `ns1::ns2::ClassA`
- `re: 'ns1::ns2::ClassA.+'` | +| `dependants` | Qualified name or regex | - `ns1::ns2::ClassA`
- `r: 'ns1::ns2::ClassA.+'` | +| `dependencies` | Qualified name or regex | - `ns1::ns2::ClassA`
- `r: 'ns1::ns2::ClassA.+'` | The following filters are available. @@ -169,7 +170,7 @@ This filter allows to include or exclude specializations and instantiations of a ## `access` -This filter allows to include or exclude class methods and members based on their access scope, allowed values are: +This filter allows to include or exclude class methods and members based on their access scope, allowed values ar: * `public` * `protected` @@ -177,7 +178,7 @@ This filter allows to include or exclude class methods and members based on thei ## `method_types` -This filter allows to include or exclude various method types from the class diagram, allowed values are: +This filter allows to include or exclude various method types from the class diagram, allowed values ar: * constructor * destructor * assignment