YAML Namespace Reference

Classes
struct	convert< access_t >
struct	convert< callee_type >
struct	convert< class_diagram >
struct	convert< config >
struct	convert< context_config >
struct	convert< context_direction_t >
struct	convert< diagram_template >
struct	convert< filter >
struct	convert< generate_links_config >
struct	convert< git_config >
struct	convert< include_diagram >
struct	convert< layout_hint >
struct	convert< mermaid >
struct	convert< method_type >
struct	convert< module_access_t >
struct	convert< namespace_or_regex >
struct	convert< package_diagram >
struct	convert< plantuml >
struct	convert< relationship_hint_t >
struct	convert< relationship_t >
struct	convert< sequence_diagram >
struct	convert< std::filesystem::path >
struct	convert< std::vector< source_location > >
struct	convert< string_or_regex >

Functions
bool	has_key (const YAML::Node &n, const std::string &key)
template<typename T >
void	get_option (const Node &node, clanguml::config::option< T > &option)
template<>
void	get_option< clanguml::common::model::namespace_ > (const Node &node, clanguml::config::option< clanguml::common::model::namespace_ > &option)
template<>
void	get_option< method_arguments > (const Node &node, clanguml::config::option< method_arguments > &option)
template<>
void	get_option< member_order_t > (const Node &node, clanguml::config::option< member_order_t > &option)
template<>
void	get_option< package_type_t > (const Node &node, clanguml::config::option< package_type_t > &option)
template<>
void	get_option< clanguml::config::comment_parser_t > (const Node &node, clanguml::config::option< clanguml::config::comment_parser_t > &option)
template<>
void	get_option< clanguml::config::filter_mode_t > (const Node &node, clanguml::config::option< clanguml::config::filter_mode_t > &option)
template<>
void	get_option< std::map< std::string, clanguml::config::diagram_template > > (const Node &node, clanguml::config::option< std::map< std::string, clanguml::config::diagram_template > > &option)
std::shared_ptr< clanguml::config::diagram >	parse_diagram_config (const Node &d)
template<typename T >
bool	decode_diagram (const Node &node, T &rhs)

Function Documentation

decode_diagram()

template<typename T >

bool YAML::decode_diagram	(	const Node &	node,
		T &	rhs
	)

Definition at line 659 of file yaml_decoders.cc.

{
    // Decode options common for all diagrams
    get_option(node, rhs.glob);
    get_option(node, rhs.using_namespace);
    get_option(node, rhs.using_module);
    get_option(node, rhs.filter_mode);
    get_option(node, rhs.include_system_headers);
    get_option(node, rhs.include);
    get_option(node, rhs.exclude);
    get_option(node, rhs.puml);
    get_option(node, rhs.mermaid);
    get_option(node, rhs.git);
    get_option(node, rhs.generate_links);
    get_option(node, rhs.type_aliases);
    get_option(node, rhs.comment_parser);
    get_option(node, rhs.debug_mode);
    get_option(node, rhs.generate_metadata);
    get_option(node, rhs.title);
    get_option(node, rhs.get_relative_to());
 
    return true;
}

get_option()

template<typename T >

void YAML::get_option	(	const Node &	node,
		clanguml::config::option< T > &	option
	)

Definition at line 68 of file yaml_decoders.cc.

{
    if (node[option.name])
        option.set(node[option.name].template as<T>());
 
    for (const auto &alt_name : option.alternate_names)
        if (node[alt_name]) {
            option.set(node[alt_name].template as<T>());
            break;
        }
}

get_option< clanguml::common::model::namespace_ >()

template<>

void YAML::get_option< clanguml::common::model::namespace_ >	(	const Node &	node,
		clanguml::config::option< clanguml::common::model::namespace_ > &	option
	)

Definition at line 81 of file yaml_decoders.cc.

{
    if (node[option.name]) {
        if (node[option.name].Type() == NodeType::Scalar)
            option.set({node[option.name].template as<std::string>()});
        else if (node[option.name].Type() == NodeType::Sequence)
            option.set(
                {node[option.name].template as<std::vector<std::string>>()[0]});
        else
            throw std::runtime_error("Invalid using_namespace value");
    }
}

get_option< clanguml::config::comment_parser_t >()

template<>

void YAML::get_option< clanguml::config::comment_parser_t >	(	const Node &	node,
		clanguml::config::option< clanguml::config::comment_parser_t > &	option
	)

Definition at line 147 of file yaml_decoders.cc.

{
    if (node[option.name]) {
        const auto &val = node[option.name].as<std::string>();
        if (val == "plain")
            option.set(clanguml::config::comment_parser_t::plain);
        else if (val == "clang")
            option.set(clanguml::config::comment_parser_t::clang);
        else
            throw std::runtime_error("Invalid comment_parser value: " + val);
    }
}

get_option< clanguml::config::filter_mode_t >()

template<>

void YAML::get_option< clanguml::config::filter_mode_t >	(	const Node &	node,
		clanguml::config::option< clanguml::config::filter_mode_t > &	option
	)

Definition at line 162 of file yaml_decoders.cc.

{
    if (node[option.name]) {
        const auto &val = node[option.name].as<std::string>();
        if (val == "basic")
            option.set(clanguml::config::filter_mode_t::basic);
        else if (val == "advanced")
            option.set(clanguml::config::filter_mode_t::advanced);
        else
            throw std::runtime_error("Invalid comment_parser value: " + val);
    }
}

get_option< member_order_t >()

template<>

void YAML::get_option< member_order_t >	(	const Node &	node,
		clanguml::config::option< member_order_t > &	option
	)

Definition at line 114 of file yaml_decoders.cc.

{
    if (node[option.name]) {
        const auto &val = node[option.name].as<std::string>();
        if (val == "as_is")
            option.set(member_order_t::as_is);
        else if (val == "lexical")
            option.set(member_order_t::lexical);
        else
            throw std::runtime_error("Invalid member_order value: " + val);
    }
}

get_option< method_arguments >()

template<>

void YAML::get_option< method_arguments >	(	const Node &	node,
		clanguml::config::option< method_arguments > &	option
	)

Definition at line 96 of file yaml_decoders.cc.

{
    if (node[option.name]) {
        const auto &val = node[option.name].as<std::string>();
        if (val == "full")
            option.set(method_arguments::full);
        else if (val == "abbreviated")
            option.set(method_arguments::abbreviated);
        else if (val == "none")
            option.set(method_arguments::none);
        else
            throw std::runtime_error(
                "Invalid generate_method_arguments value: " + val);
    }
}

get_option< package_type_t >()

template<>

void YAML::get_option< package_type_t >	(	const Node &	node,
		clanguml::config::option< package_type_t > &	option
	)

Definition at line 129 of file yaml_decoders.cc.

{
    if (node[option.name]) {
        const auto &val = node[option.name].as<std::string>();
        if (val == "namespace")
            option.set(package_type_t::kNamespace);
        else if (val == "directory")
            option.set(package_type_t::kDirectory);
        else if (val == "module")
            option.set(package_type_t::kModule);
        else
            throw std::runtime_error(
                "Invalid generate_method_arguments value: " + val);
    }
}

get_option< std::map< std::string, clanguml::config::diagram_template > >()

template<>

void YAML::get_option< std::map< std::string, clanguml::config::diagram_template > >	(	const Node &	node,
		clanguml::config::option< std::map< std::string, clanguml::config::diagram_template > > &	option
	)

Definition at line 177 of file yaml_decoders.cc.

{
    if (!node[option.name]) {
        return;
    }
 
    if (node[option.name].IsMap() && node[option.name]["include!"]) {
        auto parent_path = node["__parent_path"].as<std::string>();
 
        // Load templates from file
        auto include_path = std::filesystem::path{parent_path};
        include_path /= node[option.name]["include!"].as<std::string>();
 
        YAML::Node included_node = YAML::LoadFile(include_path.string());
 
        option.set(
            included_node.as<
                std::map<std::string, clanguml::config::diagram_template>>());
    }
    else
        option.set(node[option.name]
                       .as<std::map<std::string,
                           clanguml::config::diagram_template>>());
}

has_key()

bool YAML::has_key ( const YAML::Node &  n, const std::string &  key  )

inline

Definition at line 58 of file yaml_decoders.cc.

{
    assert(n.Type() == NodeType::Map);
 
    return std::count_if(n.begin(), n.end(), [&key](auto &&n) {
        return n.first.template as<std::string>() == key;
    }) > 0;
}

parse_diagram_config()

std::shared_ptr< clanguml::config::diagram > YAML::parse_diagram_config

(

const Node &

d

)

Definition at line 205 of file yaml_decoders.cc.

{
    const auto diagram_type = d["type"].as<std::string>();
 
    if (diagram_type == "class") {
        return std::make_shared<class_diagram>(d.as<class_diagram>());
    }
    if (diagram_type == "sequence") {
        return std::make_shared<sequence_diagram>(d.as<sequence_diagram>());
    }
    if (diagram_type == "package") {
        return std::make_shared<package_diagram>(d.as<package_diagram>());
    }
    if (diagram_type == "include") {
        return std::make_shared<include_diagram>(d.as<include_diagram>());
    }
 
    LOG_ERROR("Diagrams of type {} are not supported... ", diagram_type);
 
    return {};
}