CLI::ConfigBase Class Reference

This converter works with INI/TOML files; to write proper TOML files use ConfigTOML. More...

#include <CLI11.hpp>

Inheritance diagram for CLI::ConfigBase:

Collaboration diagram for CLI::ConfigBase:

Public Member Functions
std::string	to_config (const App *, bool default_also, bool write_description, std::string prefix) const override
	Convert an app into a configuration.
std::vector< ConfigItem >	from_config (std::istream &input) const override
	Convert a configuration into an app.
ConfigBase *	comment (char cchar)
	Specify the configuration for comment characters.
ConfigBase *	arrayBounds (char aStart, char aEnd)
	Specify the start and end characters for an array.
ConfigBase *	arrayDelimiter (char aSep)
	Specify the delimiter character for an array.
ConfigBase *	valueSeparator (char vSep)
	Specify the delimiter between a name and value.
Public Member Functions inherited from CLI::Config
virtual std::string	to_flag (const ConfigItem &item) const
	Get a flag value.
std::vector< ConfigItem >	from_file (const std::string &name)
	Parse a config file, throw an error (ParseError:ConfigParseError or FileError) on failure.
virtual	~Config ()=default
	Virtual destructor.

Protected Attributes
char	commentChar = ';'
	the character used for comments
char	arrayStart = '\0'
	the character used to start an array '\0' is a default to not use
char	arrayEnd = '\0'
	the character used to end an array '\0' is a default to not use
char	arraySeparator = ' '
	the character used to separate elements in an array
char	valueDelimiter = '='
	the character used separate the name from the value
Protected Attributes inherited from CLI::Config
std::vector< ConfigItem >	items {}

Detailed Description

Definition at line 2015 of file CLI11.hpp.

Member Function Documentation

arrayBounds()

ConfigBase * CLI::ConfigBase::arrayBounds ( char aStart, char aEnd )

inline

Definition at line 2039 of file CLI11.hpp.

                                                    {
        arrayStart = aStart;
        arrayEnd = aEnd;
        return this;
    }

arrayDelimiter()

ConfigBase * CLI::ConfigBase::arrayDelimiter ( char aSep )

inline

Definition at line 2045 of file CLI11.hpp.

                                          {
        arraySeparator = aSep;
        return this;
    }

comment()

ConfigBase * CLI::ConfigBase::comment ( char cchar )

inline

Definition at line 2034 of file CLI11.hpp.

                                    {
        commentChar = cchar;
        return this;
    }

from_config()

std::vector< ConfigItem > CLI::ConfigBase::from_config ( std::istream & ) const

inlineoverridevirtual

Implements CLI::Config.

Definition at line 7772 of file CLI11.hpp.

                                                                            {
    std::string line;
    std::string section = "default";
 
    std::vector<ConfigItem> output;
    bool defaultArray = (arrayStart == '\0' || arrayStart == ' ') && arrayStart == arrayEnd;
    char aStart = (defaultArray) ? '[' : arrayStart;
    char aEnd = (defaultArray) ? ']' : arrayEnd;
    char aSep = (defaultArray && arraySeparator == ' ') ? ',' : arraySeparator;
 
    while(getline(input, line)) {
        std::vector<std::string> items_buffer;
        std::string name;
 
        detail::trim(line);
        std::size_t len = line.length();
        if(len > 1 && line.front() == '[' && line.back() == ']') {
            if(section != "default") {
                // insert a section end which is just an empty items_buffer
                output.emplace_back();
                output.back().parents = detail::generate_parents(section, name);
                output.back().name = "--";
            }
            section = line.substr(1, len - 2);
            // deal with double brackets for TOML
            if(section.size() > 1 && section.front() == '[' && section.back() == ']') {
                section = section.substr(1, section.size() - 2);
            }
            if(detail::to_lower(section) == "default") {
                section = "default";
            } else {
                detail::checkParentSegments(output, section);
            }
            continue;
        }
        if(len == 0) {
            continue;
        }
        // comment lines
        if(line.front() == ';' || line.front() == '#' || line.front() == commentChar) {
            continue;
        }
 
        // Find = in string, split and recombine
        auto pos = line.find(valueDelimiter);
        if(pos != std::string::npos) {
            name = detail::trim_copy(line.substr(0, pos));
            std::string item = detail::trim_copy(line.substr(pos + 1));
            if(item.size() > 1 && item.front() == aStart && item.back() == aEnd) {
                items_buffer = detail::split_up(item.substr(1, item.length() - 2), aSep);
            } else if(defaultArray && item.find_first_of(aSep) != std::string::npos) {
                items_buffer = detail::split_up(item, aSep);
            } else if(defaultArray && item.find_first_of(' ') != std::string::npos) {
                items_buffer = detail::split_up(item);
            } else {
                items_buffer = {item};
            }
        } else {
            name = detail::trim_copy(line);
            items_buffer = {"true"};
        }
        if(name.find('.') == std::string::npos) {
            detail::remove_quotes(name);
        }
        // clean up quotes on the items
        for(auto &it : items_buffer) {
            detail::remove_quotes(it);
        }
 
        std::vector<std::string> parents = detail::generate_parents(section, name);
 
        if(!output.empty() && name == output.back().name && parents == output.back().parents) {
            output.back().inputs.insert(output.back().inputs.end(), items_buffer.begin(), items_buffer.end());
        } else {
            output.emplace_back();
            output.back().parents = std::move(parents);
            output.back().name = std::move(name);
            output.back().inputs = std::move(items_buffer);
        }
    }
    if(section != "default") {
        // insert a section end which is just an empty items_buffer
        std::string ename;
        output.emplace_back();
        output.back().parents = detail::generate_parents(section, ename);
        output.back().name = "--";
        while(output.back().parents.size() > 1) {
            output.push_back(output.back());
            output.back().parents.pop_back();
        }
    }
    return output;
}

Here is the call graph for this function:

to_config()

std::string CLI::ConfigBase::to_config ( const App * , bool , bool , std::string  ) const

inlineoverridevirtual

Implements CLI::Config.

Definition at line 7867 of file CLI11.hpp.

                                                                                                       {
    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"));
    if(write_description) {
        out << commentLead << app->get_description() << '\n';
    }
    for(auto &group : groups) {
        if(group == "Options" || group.empty()) {
            if(defaultUsed) {
                continue;
            }
            defaultUsed = true;
        }
        if(write_description && group != "Options" && !group.empty()) {
            out << '\n' << commentLead << group << " Options\n";
        }
        for(const Option *opt : app->get_options({})) {
 
            // Only process option with a long-name and configurable
            if(!opt->get_lnames().empty() && opt->get_configurable()) {
                if(opt->get_group() != group) {
                    if(!(group == "Options" && opt->get_group().empty())) {
                        continue;
                    }
                }
                std::string name = prefix + opt->get_lnames()[0];
                std::string value = detail::ini_join(opt->reduced_results(), arraySeparator, arrayStart, arrayEnd);
 
                if(value.empty() && default_also) {
                    if(!opt->get_default_str().empty()) {
                        value = detail::convert_arg_for_ini(opt->get_default_str());
                    } else if(opt->get_expected_min() == 0) {
                        value = "false";
                    }
                }
 
                if(!value.empty()) {
                    if(write_description && opt->has_description()) {
                        out << '\n';
                        out << commentLead << detail::fix_newlines(commentLead, opt->get_description()) << '\n';
                    }
                    out << name << valueDelimiter << value << '\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() + "." + subcom->get_name();
                    auto p = app->get_parent();
                    while(p->get_parent() != nullptr) {
                        subname = p->get_name() + "." + 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() + ".");
            }
        }
    }
 
    return out.str();
}

Here is the call graph for this function:

Here is the caller graph for this function:

valueSeparator()

ConfigBase * CLI::ConfigBase::valueSeparator ( char vSep )

inline

Definition at line 2050 of file CLI11.hpp.

                                          {
        valueDelimiter = vSep;
        return this;
    }

Member Data Documentation

arrayEnd

char CLI::ConfigBase::arrayEnd = '\0'

protected

Definition at line 2022 of file CLI11.hpp.

arraySeparator

char CLI::ConfigBase::arraySeparator = ' '

protected

Definition at line 2024 of file CLI11.hpp.

arrayStart

char CLI::ConfigBase::arrayStart = '\0'

protected

Definition at line 2020 of file CLI11.hpp.

commentChar

char CLI::ConfigBase::commentChar = ';'

protected

Definition at line 2018 of file CLI11.hpp.

valueDelimiter

char CLI::ConfigBase::valueDelimiter = '='

protected

Definition at line 2026 of file CLI11.hpp.

---

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

• programs/clio/CLI11.hpp