解决方案

Question

我正在尝试将旧的命令行工具移植到boost::program_options。该工具用于许多第三方脚本，其中一些我无法更新，因此更改命令行界面（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";
    }
}

所以我看到的问题是：

自定义验证应与解析器用于选项类型的验证相同。正如您所看到的，program_options比bool更容许validate_foo。您可以制作最后一个令牌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>>()）

提升程序选项，空字符串处理

1 个答案:

解决方案