clanguml::class_diagram::generators::text_diagram_strategy< G > Class Template Reference

Common methods for PlantUML and MermaidJS class diagrams. More...

Detailed Description

template<typename G>
class clanguml::class_diagram::generators::text_diagram_strategy< G >

Common methods for PlantUML and MermaidJS class diagrams.

Definition at line 43 of file text_diagram_strategy.h.

#include <text_diagram_strategy.h>

Public Types
using	method_groups_t = std::map< std::string, std::vector< model::class_method > >

Public Member Functions
	text_diagram_strategy (G &generator, bool generate_packages)
void	generate (const package &p, std::ostream &ostr) const
void	generate_top_level_elements (std::ostream &ostr) const
void	generate_relationships (const package &p, std::ostream &ostr) const
void	generate_relationships (std::ostream &ostr) const
void	generate_groups (std::ostream &ostr) const
template<typename T >
void	sort_class_elements (std::vector< T > &elements) const
void	generate_method_groups (const method_groups_t &methods, std::ostream &ostr) const
method_groups_t	group_methods (const std::vector< model::class_method > &methods) const
	Group class methods based on method type.

Private Attributes
const std::vector< std::string >	method_groups_
G &	generator_
common::generators::nested_element_stack< common::model::element >	together_group_stack_

Member Typedef Documentation

method_groups_t

template<typename G >

using clanguml::class_diagram::generators::text_diagram_strategy< G >::method_groups_t = std::map<std::string, std::vector<model::class_method> >

Definition at line 45 of file text_diagram_strategy.h.

Constructor & Destructor Documentation

text_diagram_strategy()

template<typename G >

clanguml::class_diagram::generators::text_diagram_strategy< G >::text_diagram_strategy ( G &  generator, bool  generate_packages  )

inline

Definition at line 48 of file text_diagram_strategy.h.

        : generator_{generator}
        , together_group_stack_{generate_packages}
    {
    }

Member Function Documentation

generate()

template<typename G >

void clanguml::class_diagram::generators::text_diagram_strategy< G >::generate ( const package &  p, std::ostream &  ostr  ) const

inline

Definition at line 54 of file text_diagram_strategy.h.

    {
        generator_.start_package(p, ostr);
 
        for (const auto &subpackage : p) {
            if (dynamic_cast<package *>(subpackage.get()) != nullptr) {
                // TODO: add option - generate_empty_packages
                const auto &sp = dynamic_cast<package &>(*subpackage);
                if (!sp.is_empty()) {
                    together_group_stack_.enter();
 
                    generate(sp, ostr);
 
                    together_group_stack_.leave();
                }
            }
            else {
                generator_.model().dynamic_apply(
                    subpackage.get(), [&](auto *el) {
                        auto together_group =
                            generator_.config().get_together_group(
                                el->full_name(false));
                        if (together_group) {
                            together_group_stack_.group_together(
                                together_group.value(), el);
                        }
                        else {
                            generator_.generate_alias(*el, ostr);
                            generator_.generate(*el, ostr);
                        }
                    });
            }
 
            if (!together_group_stack_.is_flat()) {
                generate_groups(ostr);
            }
        }
 
        generator_.end_package(p, ostr);
    }

generate_groups()

template<typename G >

void clanguml::class_diagram::generators::text_diagram_strategy< G >::generate_groups ( std::ostream &  ostr ) const

inline

Definition at line 156 of file text_diagram_strategy.h.

    {
        for (const auto &[group_name, group_elements] :
            together_group_stack_.get_current_groups()) {
 
            generator_.start_together_group(group_name, ostr);
 
            for (auto *e : group_elements) {
                generator_.model().dynamic_apply(e, [&](auto *el) {
                    generator_.generate_alias(*el, ostr);
                    generator_.generate(*el, ostr);
                });
            }
 
            generator_.end_together_group(group_name, ostr);
        }
    }

generate_method_groups()

template<typename G >

void clanguml::class_diagram::generators::text_diagram_strategy< G >::generate_method_groups ( const method_groups_t &  methods, std::ostream &  ostr  ) const

inline

Definition at line 186 of file text_diagram_strategy.h.

    {
        bool is_first_non_empty_group{true};
 
        for (const auto &group : method_groups_) {
            const auto &group_methods = methods.at(group);
            if (!group_methods.empty()) {
                if (!is_first_non_empty_group)
                    generator_.start_method_group(ostr);
                is_first_non_empty_group = false;
                generator_.generate_methods(group_methods, ostr);
            }
        }
    }

generate_relationships() [1/2]

template<typename G >

void clanguml::class_diagram::generators::text_diagram_strategy< G >::generate_relationships ( const package &  p, std::ostream &  ostr  ) const

inline

Definition at line 120 of file text_diagram_strategy.h.

    {
        for (const auto &subpackage : p) {
            if (dynamic_cast<package *>(subpackage.get()) != nullptr) {
                // TODO: add option - generate_empty_packages, currently
                //       packages which do not contain anything but other
                //       packages are skipped
                const auto &sp = dynamic_cast<package &>(*subpackage);
                if (!sp.is_empty())
                    generate_relationships(sp, ostr);
            }
            else {
                generator_.model().dynamic_apply(
                    subpackage.get(), [&](auto *el) {
                        if (generator_.model().should_include(*el)) {
                            generator_.generate_relationships(*el, ostr);
                        }
                    });
            }
        }
    }

generate_relationships() [2/2]

template<typename G >

void clanguml::class_diagram::generators::text_diagram_strategy< G >::generate_relationships ( std::ostream &  ostr ) const

inline

Definition at line 142 of file text_diagram_strategy.h.

    {
        for (const auto &p : generator_.model()) {
            if (auto *pkg = dynamic_cast<package *>(p.get()); pkg) {
                generate_relationships(*pkg, ostr);
            }
            else {
                generator_.model().dynamic_apply(p.get(), [&](auto *el) {
                    generator_.generate_relationships(*el, ostr);
                });
            }
        }
    }

generate_top_level_elements()

template<typename G >

void clanguml::class_diagram::generators::text_diagram_strategy< G >::generate_top_level_elements ( std::ostream &  ostr ) const

inline

Definition at line 95 of file text_diagram_strategy.h.

    {
        for (const auto &p : generator_.model()) {
            if (auto *pkg = dynamic_cast<package *>(p.get()); pkg) {
                if (!pkg->is_empty())
                    generate(*pkg, ostr);
            }
            else {
                generator_.model().dynamic_apply(p.get(), [&](auto *el) {
                    auto together_group =
                        generator_.config().get_together_group(
                            el->full_name(false));
                    if (together_group) {
                        together_group_stack_.group_together(
                            together_group.value(), el);
                    }
                    else {
                        generator_.generate_alias(*el, ostr);
                        generator_.generate(*el, ostr);
                    }
                });
            }
        }
    }

group_methods()

template<typename G >

method_groups_t clanguml::class_diagram::generators::text_diagram_strategy< G >::group_methods ( const std::vector< model::class_method > &  methods ) const

inline

Group class methods based on method type.

Parameters

methods

List of class methods.

Returns

Map of method groups.

Definition at line 209 of file text_diagram_strategy.h.

    {
        std::map<std::string, std::vector<model::class_method>> result;
 
        for (const auto &g : method_groups_) {
            result[g] = {};
        }
 
        for (const auto &m : methods) {
            if (m.is_constructor() || m.is_destructor()) {
                result["constructors"].push_back(m);
            }
            else if (m.is_copy_assignment() || m.is_move_assignment()) {
                result["assignment"].push_back(m);
            }
            else if (m.is_operator()) {
                result["operators"].push_back(m);
            }
            else {
                result["other"].push_back(m);
            }
        }
 
        return result;
    }

sort_class_elements()

template<typename G >

template<typename T >

void clanguml::class_diagram::generators::text_diagram_strategy< G >::sort_class_elements ( std::vector< T > &  elements ) const

inline

Definition at line 175 of file text_diagram_strategy.h.

    {
        if (generator_.config().member_order() ==
            config::member_order_t::lexical) {
            std::sort(elements.begin(), elements.end(),
                [](const auto &m1, const auto &m2) {
                    return m1.name() < m2.name();
                });
        }
    }

Member Data Documentation

generator_

template<typename G >

G& clanguml::class_diagram::generators::text_diagram_strategy< G >::generator_

private

Definition at line 240 of file text_diagram_strategy.h.

method_groups_

template<typename G >

const std::vector<std::string> clanguml::class_diagram::generators::text_diagram_strategy< G >::method_groups_

private

Initial value:

{
        "constructors", "assignment", "operators", "other"}

Definition at line 237 of file text_diagram_strategy.h.

together_group_stack_

template<typename G >

common::generators::nested_element_stack<common::model::element> clanguml::class_diagram::generators::text_diagram_strategy< G >::together_group_stack_

mutableprivate

Definition at line 242 of file text_diagram_strategy.h.

---

The documentation for this class was generated from the following file:

• src/class_diagram/generators/text_diagram_strategy.h