How to parse sequence data and store them into std::vector

[SNSerHello]

int main(int argc, const char **argv) {
std::vector input_shape;

auto cli =
lyra::cli() |
lyra::opt(input_shape, "input-shape")["--input-shape"]("input shape");

auto result = cli.parse({argc, argv});
if (!result) {
std::cerr << "Error in command line: " << result.message() << std::endl;
return 1;
}
std::cout << std::string(69, '-') << std::endl;
std::cout << "input shape : " << input_shape << std::endl;

return 0;
}

COMMAND
$ test --input-shape 1,3,224,224

HOPE
input_shape = [1, 3, 224, 224]

thank you!

[chardan]

I'm brand new to Lyra and struggling with the same issue! I'm guessing I don't understand how to compose things properly, yet (Boost program_options does things like this for you). I've read through the docs, example code, and much of the test code and am still stumped!

I'm looking for the syntax:
--opt=a,b,c,d
...but would also be ok with:
--opt a b c d
There's probably also the predictable need for:
--opt a b --opt2 x y --opt c d --opt2 z

Noticing the success handler on group(), I tried to jury-rig together something like:
std::string foo;
std::vectorstd::string v;
auto into_vec = [&foo, &v](const lyra::group&) {
// do string-splitting of foo in here
v.push_back("stuff!");
};
cli |= lyra::group(into_vec).sequential().add_argument(lyra::opt(foo,
"turkey")["--foo"] );

...but that feels really clumsy with the extra variable and just basically wrong. I'm betting there's some neat
combination trick I haven't seen yet!

[chardan]

I've tried to get this to work in any number of ways yet, but no dice; it's actually forcing me to either abandon Lyra for my project, or just use a syntax I'm not that into (I'm holding out hope and going with the latter for now!). If there's a way to construct a parser for multiple alternatives, especially interleaved ("./program command --opt1 a b c --opt2 e f g --opt1 d"), I haven't hit on it yet. Even without sequence(), opt1 appears to greedily match everything.

Generally, I've been trying things along the lines of this:

cmd_update(lyra::cli& cli)
{
cli.add_argument(
lyra::command("update",
[this](const lyra::group& g) { this->run_cmd(g); })
.help("very helpful message")

  .add_argument(
    lyra::help(show_help))
  
  .add_argument(
    lyra::arg(subject_file, "subject-file")
            .required()
            .help("The subject file"))
  
  // note: group_a and group_b :: vector<filesystem::path>
 // have also tried explicit inclusive(), but parse_inclusive() or parse_any() don't
// seem to change the results:
  .add_argument(lyra::group().optional().sequential()
            | lyra::arg(group_a, "--group-a")) // have also tried "group-a", no "--"
            | lyra::arg(group_b, "--group-b")

);
}

Is there a gadget along the lines of:
add_argument(interleave(arg1, arg2, arg3));
...or something that I'm missing? I am not yet up to understanding quite how I'd go about building one in a "nice" way, but it looks like
the main thing is that the parsers aren't stopping a switching/continuing to gather when they see a new parameter in combination with vector<>. The tests around/in arguments.hpp:527 look maybe-promising, but I so far haven't been able to patch around this.

What am I missing from correct usage? (I'm posting here because I believe it's very closely related to the OP's issue.) Or is this just not supported right now? (I would even be ok with non-interleaving, e.g., "command --group-a x y z --group-b a b c" or something similar.)

Help sure would be appreciated-- I'm enjoying Lyra a lot so far, and this is a head-scratcher. Thank you!

[grafikrobot]

Unfortunately there's nothing directly available for automatically filling an std::vector from a single arg value (the "1,2,3,4") as you are asking for. One obvious, but particularly nice, way to do it is to use the callback on options, instead of the variable ref, to do your own sub-parsing of that list. For example here's an example that minimally does what you want:

/*
Copyright 2023 René Ferdinand Rivera Morell
Distributed under the Boost Software License, Version 1.0.
(See accompanying file LICENSE.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
*/

#include <algorithm>
#include <iostream>
#include <iterator>
#include <sstream>
#include <vector>

#include <lyra/lyra.hpp>

int main(int argc, const char ** argv)
{
	using namespace lyra;

	bool show_help = false;
	std::vector<int> input_shape;

	lyra::cli cli;
	cli.add_argument(
		help(show_help).description("Parse many values into a vector."));
	cli.add_argument(opt(
		[&](std::string shape) {
			std::istringstream s(shape);
			std::string i;
			while (std::getline(s, i, ','))
			{
				int x = 0;
				if (lyra::detail::from_string(i, x)) input_shape.push_back(x);
			}
		},
		"input-shape")
						 .name("--input-shape"));

	auto result = cli.parse({ argc, argv });

	if (!result) std::cerr << result.message() << "\n\n";
	if (show_help or !result)
		std::cout << cli << "\n";
	else
	{
		std::cout << "input shape : ";
		for (auto x : input_shape) std::cout << x << " ";
		std::cout << "\n";
	}

	return 0;
}

The example does use the internal string value parsing functions. But could also be done with generic standard functions or your own. Having said that.. It wouldn't be particularly difficult to add such a feature to do the splitting of the arg value(s).