How to read subgroups from .ini based YARP configuration files?

[prashanthr05]

Is there a way to maintain subgroups based configuration using .ini files, similar to what we do in .xml files?

One of the ways, I have noticed, this being done is by including other ini files into the parent file (for example, see robotology/walking-controllers/dcm_walking_with_joypad.ini cc @GiulioRomualdi ). The contents of the child ini file is added as a sub group to the parent configuration.

[include SUBGROUP_NAME <path to another ini file>]

I was wondering if there's an alternative to do this from within the same file.

[drdanz]

I'm not sure to understand the question, but if you create a .ini file like this

foo = a
bar = b

[SUBGROUP_NAME]
foo = a
bar = b

you will get a subgroup, that should be the same as using include

[prashanthr05]

Thank you for your reply @drdanz !! :)

Sorry for not being quite clear with the question.

For example, I have a GROUP_NAME group with some configuration among which SUBGROUP_NAME is a configuration group.

baz = y
[GROUP_NAME]
foo = a
bar = b
[SUBGROUP_NAME] = ((foo_sub = c), (bar_sub = d), ...)

Now, instead of reading SUBGROUP_NAME as a separate group, I would be interested for it to be contained inside the GROUP_NAME configuration bottle.
I was wondering how to do such a nested configuration for the .ini files, which are we able to do in a straightforward manner with the xml files. (The documentation does not seem to touch on this detail of nested configurations for ini files.)

For instance, from the xml file,

<group name="GROUP_NAME">
    <parameter name=foo>a</parameter>
    <parameter name=bar>b</parameter>
    <group name="SUBGROUP_NAME">
             <parameter name="foo_sub">c</parameter>
             <parameter name="bar_sub">d</parameter>
    </group>
</group>

Although I have never tried this from command line, I suppose it must be possible by following --from GROUP_NAME::SUBGROUP_NAME::foo_sub c.

[PeterBowman]

Please note groups and nested subgroups internally translate to lists (a.k.a. bottles). For instance:

// config1.ini
test1 a

[MYGROUP]
test2 b
NESTED1 (test3 c)

After parsing this file with ResourceFinder and printing out its contents via toString(), you'll get:

(MYGROUP (test2 b) (NESTED1 (test3 c))) (from config1.ini) (test1 a)

Which is exactly the same output you'll see if your config file resembles this one:

// config2.ini
test1 a
MYGROUP (test2 b) (NESTED1 (test3 c))

Although there is no specific .ini syntax for subgroups such as there is [<group_name>] for groups, the nested-like behavior can be mimicked by abusing the parens notation. The following C++ code proves my point in that accessing nested lists via chained findGroup calls is possible, as expected:

// subgroup-test.cpp
#include <yarp/os/LogStream.h>
#include <yarp/os/ResourceFinder.h>

int main(int argc, char * argv[])
{
    yarp::os::ResourceFinder rf;
    rf.configure(argc, argv);

    yInfo() << "full config:" << rf.toString();
    yInfo() << "MYGROUP:" << rf.findGroup("MYGROUP").toString();
    yInfo() << "MYGROUP::NESTED1:" << rf.findGroup("MYGROUP").findGroup("NESTED1").toString();
    yInfo() << "MYGROUP::NESTED2:" << rf.findGroup("MYGROUP").findGroup("NESTED2").toString();

    return 0;
}

Result of subgroup-test --from config1.ini --MYGROUP::NESTED2::test4 d:

[INFO] full config: (MYGROUP (NESTED2 (test4 d)) (test2 b) (NESTED1 (test3 c))) (from config.ini) (test1 a)
[INFO] MYGROUP: MYGROUP (NESTED2 (test4 d)) (test2 b) (NESTED1 (test3 c))
[INFO] MYGROUP::NESTED1: NESTED1 (test3 c)
[INFO] MYGROUP::NESTED2: NESTED2 (test4 d)

I went a bit further to demonstrate the --GROUP::SUBGROUP::key value syntax via command line options.

[prashanthr05]

Thanks a lot @PeterBowman for the detailed explanation!!

cc @GiulioRomualdi this might be useful for you.

[prashanthr05]

Although it's seems not the best for readability of the configuration parameters, a suitable indentation pattern might render it readable.

[dummy_group]
dummy_sub_group
(     
     hello 1
     (dummy_sub_sub_group
           (hello2 2)
     )
)

[PeterBowman]

@prashanthr05 that one is actually tricky. First of all, you need to place key-value pairs within their own parentheses, such as: group (key1 value1) (key1 value2) (in contrast, please note you didn't wrap hello 1 in your example). Subgroups are no exception, they are keys for an associated list-value, so: group (nested1 (k v)) (nested2 (k v)).

For readability, I suggest escaping newlines with a backslash:

[dummy_group]
dummy_sub_group \
  (hello 1) \
  (dummy_sub_sub_group
    (hello2 2)
  )

[prashanthr05]

Oh thanks, understood. (I did not catch that detail in my example test, since I was only printing, and not yet accessing).

[drdanz]

Another option is to write something like this

[dummy_group foo]
hello 1
[dummy_group bar]
hello 2

This is equivalent to this bottle:

(dummy_group foo bar) (bar (hello 2)) (foo (hello 1))

which you can parse using findGroup("dummy_group") and then another findGroup for each value in the returned Bottle

For reference, this page has lots of information about YARP ini files: https://yarp.it/git-master/yarp_config_files.html

[prashanthr05]

Thank you @drdanz, noted.