clanguml::common::generators::detail Namespace Reference

Classes
struct	has_full_name
struct	has_full_name_no_ns
struct	has_name
struct	has_name_no_ns
struct	has_type

Functions
template<typename U >
auto	has_name_impl (int) -> decltype(std::declval< U >().name(), std::true_type{})
template<typename >
std::false_type	has_name_impl (...)
template<typename U >
auto	has_type_impl (int) -> decltype(std::declval< U >().type(), std::true_type{})
template<typename >
std::false_type	has_type_impl (...)
template<typename U >
auto	has_full_name_impl (int) -> decltype(std::declval< U >().full_name(std::declval< bool >()), std::true_type{})
template<typename >
std::false_type	has_full_name_impl (...)
template<typename U >
auto	has_name_no_ns_impl (int) -> decltype(std::declval< U >().name_no_ns(), std::true_type{})
template<typename >
std::false_type	has_name_no_ns_impl (...)
template<typename U >
auto	has_full_name_no_ns_impl (int) -> decltype(std::declval< U >().full_name_no_ns(), std::true_type{})
template<typename >
std::false_type	has_full_name_no_ns_impl (...)
template<typename DiagramConfig , typename GeneratorTag , typename DiagramModel >
void	generate_diagram_select_generator (const std::string &od, const std::string &name, std::shared_ptr< clanguml::config::diagram > diagram, const DiagramModel &model)
template<typename DiagramConfig >
void	generate_diagram_impl (const std::string &name, std::shared_ptr< clanguml::config::diagram > diagram, const common::compilation_database &db, const std::vector< std::string > &translation_units, const cli::runtime_config &runtime_config, std::function< void()> &&progress)

Function Documentation

generate_diagram_impl()

template<typename DiagramConfig >

void clanguml::common::generators::detail::generate_diagram_impl	(	const std::string &	name,
		std::shared_ptr< clanguml::config::diagram >	diagram,
		const common::compilation_database &	db,
		const std::vector< std::string > &	translation_units,
		const cli::runtime_config &	runtime_config,
		std::function< void()> &&	progress
	)

Definition at line 129 of file generators.cc.

{
    using diagram_config = DiagramConfig;
    using diagram_model = typename diagram_model_t<DiagramConfig>::type;
    using diagram_visitor = typename diagram_visitor_t<DiagramConfig>::type;
 
    auto model = clanguml::common::generators::generate<diagram_model,
        diagram_config, diagram_visitor>(db, diagram->name,
        dynamic_cast<diagram_config &>(*diagram), translation_units,
        runtime_config.verbose, std::move(progress));
 
    if constexpr (std::is_same_v<DiagramConfig, config::sequence_diagram>) {
        if (runtime_config.print_from) {
            auto from_values = model->list_from_values();
 
            if (logging::logger_type() == logging::logger_type_t::text) {
                for (const auto &from : from_values) {
                    std::cout << from << '\n';
                }
            }
            else {
                inja::json j = inja::json::array();
                for (const auto &from : from_values) {
                    j.emplace_back(logging::escape_json(from));
                }
                std::cout << j.dump();
            }
 
            return;
        }
        if (runtime_config.print_to) {
            auto to_values = model->list_to_values();
            if (logging::logger_type() == logging::logger_type_t::text) {
                for (const auto &to : to_values) {
                    std::cout << to << '\n';
                }
            }
            else {
                inja::json j = inja::json::array();
                for (const auto &to : to_values) {
                    j.emplace_back(logging::escape_json(to));
                }
                std::cout << j.dump();
            }
            return;
        }
    }
 
    for (const auto generator_type : runtime_config.generators) {
        if (generator_type == generator_type_t::plantuml) {
            generate_diagram_select_generator<diagram_config,
                plantuml_generator_tag>(
                runtime_config.output_directory, name, diagram, model);
        }
        else if (generator_type == generator_type_t::json) {
            generate_diagram_select_generator<diagram_config,
                json_generator_tag>(
                runtime_config.output_directory, name, diagram, model);
        }
        else if (generator_type == generator_type_t::mermaid) {
            generate_diagram_select_generator<diagram_config,
                mermaid_generator_tag>(
                runtime_config.output_directory, name, diagram, model);
        }
        else if (generator_type == generator_type_t::graphml) {
            generate_diagram_select_generator<diagram_config,
                graphml_generator_tag>(
                runtime_config.output_directory, name, diagram, model);
        }
 
        // Convert plantuml or mermaid to an image using command provided
        // in the command line arguments
        if (runtime_config.render_diagrams) {
            render_diagram(generator_type, diagram);
        }
    }
}

generate_diagram_select_generator()

template<typename DiagramConfig , typename GeneratorTag , typename DiagramModel >

void clanguml::common::generators::detail::generate_diagram_select_generator	(	const std::string &	od,
		const std::string &	name,
		std::shared_ptr< clanguml::config::diagram >	diagram,
		const DiagramModel &	model
	)

Definition at line 97 of file generators.cc.

{
    using diagram_generator =
        typename diagram_generator_t<DiagramConfig, GeneratorTag>::type;
 
    if constexpr (!std::is_same_v<diagram_generator, not_supported>) {
 
        std::stringstream buffer;
        buffer << diagram_generator(
            dynamic_cast<DiagramConfig &>(*diagram), *model);
 
        // Only open the file after the diagram has been generated successfully
        // in order not to overwrite previous diagram in case of failure
        auto path = std::filesystem::path{od} /
            fmt::format("{}.{}", name, GeneratorTag::extension);
        std::ofstream ofs;
        ofs.open(path, std::ofstream::out | std::ofstream::trunc);
        ofs << buffer.str();
 
        ofs.close();
 
        LOG_INFO("Written {} diagram to {}", name, path.string());
    }
    else {
        LOG_INFO("Serialization to {} not supported for {}",
            GeneratorTag::extension, name);
    }
}

has_full_name_impl() [1/2]

template<typename >

std::false_type clanguml::common::generators::detail::has_full_name_impl

(

...

)

has_full_name_impl() [2/2]

template<typename U >

auto clanguml::common::generators::detail::has_full_name_impl

(

int

)

-> decltype(std::declval< U >().full_name(std::declval< bool >()), std::true_type{})

has_full_name_no_ns_impl() [1/2]

template<typename >

std::false_type clanguml::common::generators::detail::has_full_name_no_ns_impl

(

...

)

has_full_name_no_ns_impl() [2/2]

template<typename U >

auto clanguml::common::generators::detail::has_full_name_no_ns_impl

(

int

)

-> decltype(std::declval< U >().full_name_no_ns(), std::true_type{})

has_name_impl() [1/2]

template<typename >

std::false_type clanguml::common::generators::detail::has_name_impl

(

...

)

has_name_impl() [2/2]

template<typename U >

auto clanguml::common::generators::detail::has_name_impl

(

int

)

-> decltype(std::declval< U >().name(), std::true_type{})

has_name_no_ns_impl() [1/2]

template<typename >

std::false_type clanguml::common::generators::detail::has_name_no_ns_impl

(

...

)

has_name_no_ns_impl() [2/2]

template<typename U >

auto clanguml::common::generators::detail::has_name_no_ns_impl

(

int

)

-> decltype(std::declval< U >().name_no_ns(), std::true_type{})

has_type_impl() [1/2]

template<typename >

std::false_type clanguml::common::generators::detail::has_type_impl

(

...

)

has_type_impl() [2/2]

template<typename U >

auto clanguml::common::generators::detail::has_type_impl

(

int

)

-> decltype(std::declval< U >().type(), std::true_type{})