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 语法的验证器，用于识别 "extra" 参数。

我将从最酷的部分开始：

./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 选项的末尾处理一个额外的标记。它调用自定义验证并将最后一个有问题的标记移动到位置参数。我在代码之后描述了一些注意事项。我特意留下了一些调试 couts 以便任何人都可以轻松地使用它。

所以这里是 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";
    }
}

所以我看到的问题是：

自定义验证应与解析器用于选项类型的验证相同。如您所见，program_options 比 validate_foo 对 bool 更宽容。您可以制作最后一个令牌 false 并且它会被错误地移动。我不知道如何提取库用于该选项的验证器，所以我提供了一个粗略的自定义版本。
向 basic_parsed_options::option 添加一个条目是相当棘手的。它基本上会扰乱对象的内部状态。正如你所看到的，我制作了一个相当初级的版本，例如它复制 value，但单独留下 original_tokens 向量，从而在数据结构中造成差异。其他字段也保持原样。
如果您不考虑命令行中其他位置出现的 positional 参数，可能会发生奇怪的事情。这意味着 command_line_parser 将在 basic_parsed_options::option 中创建一个条目，而代码将添加另一个具有相同 string_key 的条目。我不确定后果，但它确实适用于我使用的奇怪示例。

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

您可以删除有问题的令牌并将它们放在一边，但将其留给 boost_options 仍然使用它的验证例程，这可能很好。（你可以试试把positional改成value<std::vector<int>>()）

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

Boost program options, empty string handling

c++

command-line

boost

boost-program-options

解决方案