c++ - Boost 程序选项，空字符串处理

Question

我正在尝试将旧的命令行工具移植到 boost::program_options。该工具用于许多第 3 方脚本，其中一些我无法更新，因此更改命令行界面 (CLI) 不适合我。

我有一个位置参数、几个标志和常规参数。但是我遇到了 ranges 参数的问题。它应该按如下方式工作:

> my_too.exe -ranges 1,2,4-7,4 some_file.txt    # args[ranges]="1,2,4-7,4"
> my_too.exe -ranges -other_param some_file.txt # args[ranges]=""
> my_too.exe -ranges some_file.txt              # args[ranges]=""

基本上，如果满足其他参数或类型不匹配，我希望 boost::po 停止解析参数值。有没有一种方法可以准确地实现这种行为？

我尝试使用 implicit_value 但它不起作用，因为它需要更改 CLI 格式(需要使用键调整参数):

> my_too.exe -ranges="1,2-3,7" some_file.txt

我尝试使用 multitoken, zero_tokens 技巧，但它不会在满足位置参数或参数不匹配时停止。

> my_tool.exe -ranges 1,2-4,7 some_file.txt # args[ranges]=1,2-4,7,some_file.txt

有什么想法吗？

Answer 1

这并不简单，但是您需要的语法很奇怪，肯定需要进行一些手动调整，例如multitoken 的验证器语法，以识别“额外”参数。

我将从最酷的部分开始:

./a.out 1st_positional --foo yes off false yes file.txt --bar 5 -- another positional
parsed foo values: 1, 0, 0, 1,
parsed bar values: 5
parsed positional values: 1st_positional, another, positional, file.txt,

因此，即使对于非常奇怪的选项组合，它似乎也能正常工作。它还处理:

./a.out 1st_positional --foo --bar 5 -- another positional
./a.out 1st_positional --foo file.txt --bar 5 -- another positional

解决方案

您可以在运行 command_line_parser 后手动篡改已识别的值, 在使用前 store .

以下是草稿。它在 --foo 末尾处理一个额外的标记multitoken选项。它调用自定义验证并将最后一个有问题的标记移动到位置参数。我在代码之后描述了一些注意事项。我留下了一些调试 cout这是故意的，这样任何人都可以轻松地玩它。

所以这里是 draft :

#include <vector>
#include <boost/program_options/options_description.hpp>
#include <boost/program_options/parsers.hpp>
#include <boost/program_options/variables_map.hpp>
#include <boost/program_options/positional_options.hpp>
#include <boost/program_options/option.hpp>
#include <algorithm>

using namespace boost::program_options;

#include <iostream>
using namespace std;

// A helper function to simplify the main part.
template<class T>
ostream& operator<<(ostream& os, const vector<T>& v)
{
    copy(v.begin(), v.end(), ostream_iterator<T>(os, ", ")); 
    return os;
}

bool validate_foo(const string& s)
{
    return s == "yes" || s == "no";
}

int main(int ac, char* av[])
{
    try {
        options_description desc("Allowed options");
        desc.add_options()
        ("help", "produce a help message")
        ("foo", value<std::vector<bool>>()->multitoken()->zero_tokens())
        ("bar", value<int>())
        ("positional", value<std::vector<string>>())
        ;

        positional_options_description p;
        p.add("positional", -1);

        variables_map vm;
        auto clp = command_line_parser(ac, av).positional(p).options(desc).run();

        // ---------- Crucial part -----------
        auto foo_itr = find_if( begin(clp.options), end(clp.options), [](const auto& opt) { return opt.string_key == string("foo"); });
        if ( foo_itr != end(clp.options) ) { 
            auto& foo_opt = *foo_itr;

            cout << foo_opt.string_key << '\n';
            std::cout << "foo values: " << foo_opt.value << '\n';

            if ( !validate_foo(foo_opt.value.back()) ) {                                        // [1]
                auto last_value = foo_opt.value.back(); //consider std::move
                foo_opt.value.pop_back();

                cout << "Last value of foo (`" << last_value << "`) seems wrong. Let's take care of it.\n";

                clp.options.emplace_back(string("positional"), vector<string>{last_value} );    // [2]
            }
        }
        // ~~~~~~~~~~ Crucial part ~~~~~~~~~~~~

        auto pos = find_if( begin(clp.options), end(clp.options), [](const auto& opt) { return opt.string_key == string("positional"); });
        if ( pos != end(clp.options)) {
            auto& pos_opt = *pos;
            cout << "positional pos_key: " << pos_opt.position_key << '\n';
            cout << "positional string_key: " << pos_opt.string_key << '\n';
            cout << "positional values: " << pos_opt.value << '\n';
            cout << "positional original_tokens: " << pos_opt.original_tokens << '\n';
        }

        store(clp, vm);
        notify(vm);

        if (vm.count("help")) {
            cout << desc;
        }
        if (vm.count("foo")) {
            cout << "parsed foo values: " 
                 << vm["foo"].as<vector<bool>>() << "\n";
        }
        if (vm.count("bar")) {
            cout << "parsed bar values: " 
                 << vm["bar"].as<int>() << "\n";
        }        
        if (vm.count("positional")) {
            cout << "parsed positional values: " <<
                vm["positional"].as< vector<string> >() << "\n";
        }
    }
    catch(exception& e) {
        cout << e.what() << "\n";
    }
}

所以我看到的问题是:

1. 自定义验证应该与解析器对选项类型使用的验证相同。如你所见program_options对 bool 更宽容比validate_foo .您可以制作最后一个 token false它会被错误地移动。我不知道如何提取库用于该选项的验证器，所以我提供了一个粗略的自定义版本。

2. 添加条目到 basic_parsed_options::option相当棘手。它基本上会扰乱对象的内部状态。正如你所看到的，我制作了一个相当初级的版本，例如它复制value , 但离开 original_tokens vector 单独创建数据结构中的差异。其他字段也保持原样。

3. 如果您不考虑 positional，可能会发生奇怪的事情参数出现在命令行的其他地方。这意味着 command_line_parser将在 basic_parsed_options::option 中创建一个条目, 并且代码会添加另一个具有相同 string_key 的代码.我不确定后果，但它确实适用于我使用的奇怪示例。

解决问题 1. 可以使它成为一个很好的解决方案。我猜其他东西是用于诊断的。 (虽然不是 100% 确定!)。还可以通过其他方式或在循环中识别违规 token 。

您可以删除有问题的 token 并将它们放在一边，但将其留给 boost_options仍然使用它的验证例程，这很好。 (您可以尝试将 positional 更改为 value<std::vector<int>>() )