Changed scope_t to access_t and fixed friend access specifier handling

src/common/model/diagram.cc

@@ -68,7 +68,7 @@ bool diagram::should_include(const relationship_t r) const
     return filter_->should_include(r);
 }
 
-bool diagram::should_include(const scope_t s) const
+bool diagram::should_include(const access_t s) const
 {
     if (filter_.get() == nullptr)
         return true;

src/common/model/diagram.h

@@ -52,7 +52,7 @@ public:
     bool should_include(const std::string &e) const;
     bool should_include(const relationship r) const;
     bool should_include(const relationship_t r) const;
-    bool should_include(const scope_t s) const;
+    bool should_include(const access_t s) const;
     bool should_include(const namespace_ &ns, const std::string &name) const;
 
 private:

src/common/model/diagram_filter.cc

@@ -20,6 +20,11 @@
 
 namespace clanguml::common::model {
 
+filter_visitor::filter_visitor(filter_t type)
+    : type_{type}
+{
+}
+
 std::optional<bool> filter_visitor::match(
     const diagram &d, const common::model::element &e) const
 {
@@ -33,7 +38,7 @@ std::optional<bool> filter_visitor::match(
 }
 
 std::optional<bool> filter_visitor::match(
-    const diagram &d, const common::model::scope_t &r) const
+    const diagram &d, const common::model::access_t &a) const
 {
     return {};
 }
@@ -172,20 +177,20 @@ std::optional<bool> relationship_filter::match(
         [&r](const auto &rel) { return r == rel; });
 }
 
-scope_filter::scope_filter(filter_t type, std::vector<scope_t> scopes)
+access_filter::access_filter(filter_t type, std::vector<access_t> access)
     : filter_visitor{type}
-    , scopes_{scopes}
+    , access_{access}
 {
 }
 
-std::optional<bool> scope_filter::match(
-    const diagram &d, const scope_t &s) const
+std::optional<bool> access_filter::match(
+    const diagram &d, const access_t &a) const
 {
-    if (scopes_.empty())
+    if (access_.empty())
         return {};
 
-    return std::any_of(scopes_.begin(), scopes_.end(),
-        [&s](const auto &scope) { return s == scope; });
+    return std::any_of(access_.begin(), access_.end(),
+        [&a](const auto &access) { return a == access; });
 }
 
 context_filter::context_filter(filter_t type, std::vector<std::string> context)
@@ -246,8 +251,8 @@ void diagram_filter::init_filters(const config::diagram &c)
             filter_t::kInclusive, c.include().namespaces));
         inclusive_.emplace_back(std::make_unique<relationship_filter>(
             filter_t::kInclusive, c.include().relationships));
-        inclusive_.emplace_back(std::make_unique<scope_filter>(
-            filter_t::kInclusive, c.include().scopes));
+        inclusive_.emplace_back(std::make_unique<access_filter>(
+            filter_t::kInclusive, c.include().access));
         inclusive_.emplace_back(std::make_unique<element_filter>(
             filter_t::kInclusive, c.include().elements));
         inclusive_.emplace_back(std::make_unique<subclass_filter>(
@@ -264,8 +269,8 @@ void diagram_filter::init_filters(const config::diagram &c)
             filter_t::kExclusive, c.exclude().elements));
         exclusive_.emplace_back(std::make_unique<relationship_filter>(
             filter_t::kExclusive, c.exclude().relationships));
-        exclusive_.emplace_back(std::make_unique<scope_filter>(
-            filter_t::kExclusive, c.exclude().scopes));
+        exclusive_.emplace_back(std::make_unique<access_filter>(
+            filter_t::kExclusive, c.exclude().access));
         exclusive_.emplace_back(std::make_unique<subclass_filter>(
             filter_t::kExclusive, c.exclude().subclasses));
         exclusive_.emplace_back(std::make_unique<context_filter>(

src/common/model/diagram_filter.h

@@ -32,10 +32,7 @@ enum filter_t { kInclusive, kExclusive };
 
 class filter_visitor {
 public:
-    filter_visitor(filter_t type)
-        : type_{type}
-    {
-    }
+    filter_visitor(filter_t type);
 
     virtual std::optional<bool> match(
         const diagram &d, const common::model::element &e) const;
@@ -44,7 +41,7 @@ public:
         const diagram &d, const common::model::relationship_t &r) const;
 
     virtual std::optional<bool> match(
-        const diagram &d, const common::model::scope_t &r) const;
+        const diagram &d, const common::model::access_t &a) const;
 
     virtual std::optional<bool> match(
         const diagram &d, const common::model::namespace_ &ns) const;
@@ -102,14 +99,14 @@ private:
     std::vector<relationship_t> relationships_;
 };
 
-struct scope_filter : public filter_visitor {
-    scope_filter(filter_t type, std::vector<scope_t> scopes);
+struct access_filter : public filter_visitor {
+    access_filter(filter_t type, std::vector<access_t> access);
 
     std::optional<bool> match(
-        const diagram &d, const scope_t &s) const override;
+        const diagram &d, const access_t &a) const override;
 
 private:
-    std::vector<scope_t> scopes_;
+    std::vector<access_t> access_;
 };
 
 struct context_filter : public filter_visitor {

src/common/model/enums.cc

@@ -49,22 +49,6 @@ std::string to_string(relationship_t r)
     }
 }
 
-std::string to_string(scope_t s)
-{
-    switch (s) {
-    case scope_t::kPublic:
-        return "public";
-    case scope_t::kProtected:
-        return "protected";
-    case scope_t::kPrivate:
-        return "private";
-    case scope_t::kNone:
-        return "none";
-    default:
-        assert(false);
-    }
-}
-
 std::string to_string(access_t a)
 {
     switch (a) {

src/common/model/enums.h

@@ -23,8 +23,6 @@ namespace clanguml::common::model {
 
 enum class access_t { kPublic, kProtected, kPrivate };
 
-enum class scope_t { kPublic, kProtected, kPrivate, kNone };
-
 enum class relationship_t {
     kNone,
     kExtension,
@@ -42,8 +40,6 @@ enum class message_t { kCall, kReturn };
 
 std::string to_string(relationship_t r);
 
-std::string to_string(scope_t r);
-
 std::string to_string(access_t r);
 
 std::string to_string(message_t r);

src/common/model/relationship.cc

@@ -21,12 +21,12 @@
 namespace clanguml::common::model {
 
 relationship::relationship(relationship_t type, const std::string &destination,
-    scope_t scope, const std::string &label,
+    access_t access, const std::string &label,
     const std::string &multiplicity_source,
     const std::string &multiplicity_destination)
     : type_{type}
     , destination_{destination}
-    , scope_{scope}
+    , access_{access}
     , label_{label}
     , multiplicity_source_{multiplicity_source}
     , multiplicity_destination_{multiplicity_destination}
@@ -70,9 +70,9 @@ void relationship::set_label(const std::string &label) { label_ = label; }
 
 std::string relationship::label() const { return label_; }
 
-void relationship::set_scope(scope_t scope) noexcept { scope_ = scope; }
+void relationship::set_access(access_t access) noexcept { access_ = access; }
 
-scope_t relationship::scope() const noexcept { return scope_; }
+access_t relationship::access() const noexcept { return access_; }
 
 bool operator==(const relationship &l, const relationship &r)
 {

src/common/model/relationship.h

@@ -28,7 +28,7 @@ class relationship : public common::model::decorated_element,
                      public common::model::stylable_element {
 public:
     relationship(relationship_t type, const std::string &destination,
-        scope_t scope = scope_t::kNone, const std::string &label = "",
+        access_t access = access_t::kPublic, const std::string &label = "",
         const std::string &multiplicity_source = "",
         const std::string &multiplicity_destination = "");
 
@@ -50,8 +50,8 @@ public:
     void set_label(const std::string &label);
     std::string label() const;
 
-    void set_scope(scope_t scope) noexcept;
-    scope_t scope() const noexcept;
+    void set_access(access_t scope) noexcept;
+    access_t access() const noexcept;
 
     friend bool operator==(const relationship &l, const relationship &r);
 
@@ -61,6 +61,6 @@ private:
     std::string multiplicity_source_;
     std::string multiplicity_destination_;
     std::string label_;
-    scope_t scope_{scope_t::kNone};
+    access_t access_{access_t::kPublic};
 };
 }