CLI::ConfigFormatter Class Reference

#include <Formatter.h>

Inheritance diagram for CLI::ConfigFormatter:

Collaboration diagram for CLI::ConfigFormatter:

Public Member Functions
	ConfigFormatter ()
	~ConfigFormatter () override

Private Member Functions
std::string	to_config (const App *app, bool default_also, bool write_description, std::string prefix) const override

Detailed Description

Definition at line 78 of file Formatter.h.

Constructor & Destructor Documentation

ConfigFormatter()

CLI::ConfigFormatter::ConfigFormatter

(

)

Definition at line 59 of file Formatter.cpp.

                                     {
        arrayDelimiter(' ');
    }

~ConfigFormatter()

CLI::ConfigFormatter::~ConfigFormatter ( )

override

Definition at line 63 of file Formatter.cpp.

                                      {
    }

Member Function Documentation

to_config()

CLI11_INLINE std::string CLI::ConfigFormatter::to_config ( const App * app, bool default_also, bool write_description, std::string prefix ) const

overrideprivate

Definition at line 67 of file Formatter.cpp.

                                                                                                                {
        std::stringstream out;
        std::string commentLead;
        commentLead.push_back(commentChar);
        commentLead.push_back(' ');
 
        std::vector<std::string> groups = app->get_groups();
        bool defaultUsed = false;
        groups.insert(groups.begin(), std::string("Options"));
        for (const auto& group : groups) {
            if (group == "Options" || group.empty()) {
                if (defaultUsed) {
                    continue;
                }
                defaultUsed = true;
            }
            if (write_description && group != "Options" && !group.empty() &&
                !app->get_options([group](const Option* opt) -> bool {
                        return opt->get_group() == group && opt->get_configurable();
                    })
                     .empty()) {
                out << '\n' << commentChar << commentLead << group << "\n";
            }
            for (const Option* opt : app->get_options({})) {
                // Only process options that are configurable
                if (opt->get_configurable()) {
                    if (opt->get_group() != group) {
                        if (!(group == "Options" && opt->get_group().empty())) {
                            continue;
                        }
                    }
                    const std::string name = prefix + opt->get_single_name();
                    std::string value;
                    try {
                        value = detail::ini_join(opt->reduced_results(), arraySeparator, arrayStart, arrayEnd, stringQuote, literalQuote);
                    } catch (CLI::ParseError& e) {
                        value = std::string{"<["} + Color::Code::FG_RED + e.get_name() + Color::Code::FG_DEFAULT + "] " + e.what() + ">";
                    }
 
                    std::string defaultValue{};
                    if (default_also) {
                        static_assert(std::string::npos + static_cast<std::string::size_type>(1) == 0,
                                      "std::string::npos + static_cast<std::string::size_type>(1) != 0");
                        if (!value.empty() &&
                            detail::convert_arg_for_ini(opt->get_default_str(), stringQuote, literalQuote, true) == "\"" + value + "\"") {
                            value.clear();
                        }
                        if (!opt->get_default_str().empty()) {
                            defaultValue = detail::convert_arg_for_ini(opt->get_default_str(), stringQuote, literalQuote, true);
                            if (defaultValue == "'\"\"'") {
                                defaultValue = "";
                            }
                        } else if (opt->get_run_callback_for_default()) {
                            defaultValue = "\"\""; // empty string default value
                        } else if (opt->get_required()) {
                            defaultValue = "\"<REQUIRED>\"";
                        } else if (opt->get_expected_min() == 0) {
                            defaultValue = "false";
                        } else {
                            defaultValue = "\"\"";
                        }
                    }
                    if (write_description && opt->has_description() && (default_also || !value.empty())) {
                        out << commentLead << detail::fix_newlines(commentLead, opt->get_description()) << '\n';
                    }
                    if (default_also && !defaultValue.empty()) {
                        if (defaultValue == value) {
                            value.clear();
                        }
                        out << commentChar << name << valueDelimiter << defaultValue << "\n";
                    }
                    if (!value.empty()) {
                        if (!opt->get_fnames().empty()) {
                            value = opt->get_flag_value(name, value);
                        }
                        if (value == "\"default\"") {
                            value = "default";
                        }
                        out << name << valueDelimiter << value << "\n\n";
                    } else {
                        out << '\n';
                    }
                }
            }
        }
        auto subcommands = app->get_subcommands({});
        for (const App* subcom : subcommands) {
            if (subcom->get_name().empty()) {
                if (write_description && !subcom->get_group().empty()) {
                    out << '\n' << commentLead << subcom->get_group() << " Options\n";
                }
                out << to_config(subcom, default_also, write_description, prefix);
            }
        }
 
        for (const App* subcom : subcommands) {
            if (!subcom->get_name().empty()) {
                if (subcom->get_configurable() && app->got_subcommand(subcom)) {
                    if (!prefix.empty() || app->get_parent() == nullptr) {
                        out << '[' << prefix << subcom->get_name() << "]\n";
                    } else {
                        std::string subname = app->get_name() + parentSeparatorChar + subcom->get_name();
                        const auto* p = app->get_parent();
                        while (p->get_parent() != nullptr) {
                            subname = p->get_name() + parentSeparatorChar + subname;
                            p = p->get_parent();
                        }
                        out << '[' << subname << "]\n";
                    }
                    out << to_config(subcom, default_also, write_description, "");
                } else {
                    out << to_config(subcom, default_also, write_description, prefix + subcom->get_name() + parentSeparatorChar);
                }
            }
        }
 
        std::string outString;
        if (write_description && !out.str().empty()) {
            outString =
                commentChar + std::string("#") + commentLead + detail::fix_newlines(commentChar + commentLead, app->get_description());
        }
 
        return outString + out.str();
    }

References Color::FG_DEFAULT, Color::FG_RED, Color::operator+(), and to_config().

Referenced by to_config().

Here is the call graph for this function:

Here is the caller graph for this function:

---

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

• utils/Formatter.h
• utils/Formatter.cpp