[fusion][?] a dictionary with compile time (or types as) keys

older
Boost or Standard when there is...

Nick Stokes

16 Feb 2014 16 Feb '14

6:30 p.m.

The problem is the following: class TypeDictionary { public: // implementation be here -- and the question is about this }; struct Foo; struct Bar; void userOfTypeDictionary() { TypeDictionary td; td.insert( Foo() ); td.insert( Bar() ); td,insert( double(3.14) ); // and other unknown (to TypeDictionary) // list of types attached // later on, in a different scope perhaps Foo& f = td.get<Foo>() ; Bar& f = td.get<Bar>(); double pi = tg.get<double>(); // ... } Now the question so far seems like right up in the alley of Boost.Fusion, perhaps with a boost::fusion::set, but I am unsure how to manipulate a set of types unknown ahead of time as in code above, and with a -- rather obvious -- extension whereby different instances of TypeDictionary would be used to contain a different set of types, potentially in different compilation units. As for a realistic motivating use case, think of a plugin manager. At any given time of its life an arbitrary heterogeneous set of objects are attached to it, and the it is the manager's job to manage the life time of the attached objects and return (a reference) to them when queried in a type-safe manner. Any ideas on whether such a thing is possible, and how, would be deeply appreciated. Thanks many, Nick

Attachments:

attachment.html (text/html — 2.0 KB)

Show replies by date

Larry Evans

17 Feb 17 Feb

1:20 p.m.

New subject: [fusion][?] a dictionary with compile time (or types as) keys

On 02/16/14 12:30, Nick Stokes wrote:

...

The problem is the following:

class TypeDictionary { public: // implementation be here -- and the question is about this };

struct Foo; struct Bar;

void userOfTypeDictionary() {

TypeDictionary td; td.insert( Foo() ); td.insert( Bar() ); td,insert( double(3.14) ); // and other unknown (to TypeDictionary) // list of types attached

// later on, in a different scope perhaps Foo& f = td.get<Foo>() ; Bar& f = td.get<Bar>(); double pi = tg.get<double>(); // ... }

Now the question so far seems like right up in the alley of Boost.Fusion, perhaps with a boost::fusion::set, but I am unsure how to manipulate a set of types unknown ahead of time as in code above, and with a -- rather obvious -- extension whereby different instances of TypeDictionary would be used to contain a different set of types, potentially in different compilation units.

As for a realistic motivating use case, think of a plugin manager. At any given time of its life an arbitrary heterogeneous set of objects are attached to it, and the it is the manager's job to manage the life time of the attached objects and return (a reference) to them when queried in a type-safe manner.

Any ideas on whether such a thing is possible, and how, would be deeply appreciated.

Thanks many, Nick

Wouldn't: http://www.boost.org/doc/libs/1_55_0/libs/fusion/doc/html/fusion/container/m... work? -regards, Larry

Gordon Woodhull

5:20 p.m.

New subject: [fusion][?] a dictionary with compile time (or types as) keys

...

On Feb 17, 2014, at 8:20 AM, Larry Evans wrote:

...
On 02/16/14 12:30, Nick Stokes wrote: The problem is the following:

class TypeDictionary { public: // implementation be here -- and the question is about this };

struct Foo; struct Bar;

void userOfTypeDictionary() {

TypeDictionary td; td.insert( Foo() ); td.insert( Bar() ); td,insert( double(3.14) ); // and other unknown (to TypeDictionary) // list of types attached

// later on, in a different scope perhaps Foo& f = td.get<Foo>() ; Bar& f = td.get<Bar>(); double pi = tg.get<double>(); // ... }

Now the question so far seems like right up in the alley of Boost.Fusion, perhaps with a boost::fusion::set, but I am unsure how to manipulate a set of types unknown ahead of time as in code above, and with a -- rather obvious -- extension whereby different instances of TypeDictionary would be used to contain a different set of types, potentially in different compilation units.

As for a realistic motivating use case, think of a plugin manager. At any given time of its life an arbitrary heterogeneous set of objects are attached to it, and the it is the manager's job to manage the life time of the attached objects and return (a reference) to them when queried in a type-safe manner.

Any ideas on whether such a thing is possible, and how, would be deeply appreciated.

Thanks many, Nick Wouldn't:

http://www.boost.org/doc/libs/1_55_0/libs/fusion/doc/html/fusion/container/m...

work?

I think the OP is looking for something runtime, i.e. type-erased. I know I have seen such a thing but I don't recall seeing one in Boost. Cheers, Gordon

Nick Stokes

8:23 p.m.

New subject: [fusion][?] a dictionary with compile time (or types as) keys

On Mon, Feb 17, 2014 at 12:20 PM, Gordon Woodhull wrote:

...

...
...
Thanks many, Nick

Wouldn't:

http://www.boost.org/doc/libs/1_55_0/libs/fusion/doc/html/fusion/container/m...

...
work?

I think the OP is looking for something runtime, i.e. type-erased. I know I have seen such a thing but I don't recall seeing one in Boost.

Yes, indeed.

Vicente J. Botet Escriba

6:22 p.m.

New subject: [fusion][?] a dictionary with compile time (or types as) keys

Le 16/02/14 19:30, Nick Stokes a écrit :

...

The problem is the following:

class TypeDictionary { public: // implementation be here -- and the question is about this };

struct Foo; struct Bar;

void userOfTypeDictionary() {

TypeDictionary td; td.insert( Foo() ); td.insert( Bar() ); td,insert( double(3.14) ); // and other unknown (to TypeDictionary) // list of types attached

// later on, in a different scope perhaps Foo& f = td.get<Foo>() ; Bar& f = td.get<Bar>(); double pi = tg.get<double>(); // ... }

Now the question so far seems like right up in the alley of Boost.Fusion, perhaps with a boost::fusion::set, but I am unsure how to manipulate a set of types unknown ahead of time as in code above, and with a -- rather obvious -- extension whereby different instances of TypeDictionary would be used to contain a different set of types, potentially in different compilation units.

As for a realistic motivating use case, think of a plugin manager. At any given time of its life an arbitrary heterogeneous set of objects are attached to it, and the it is the manager's job to manage the life time of the attached objects and return (a reference) to them when queried in a type-safe manner.

Any ideas on whether such a thing is possible, and how, would be deeply appreciated.

Hi, we have added to Boost.Application a class aspect_map [1] that is quite close to your expectations. It could be proposed independently. There is also a Boost.Mixin proposal that could help also. HTH, Vicente https://github.com/retf/Boost.Application/blob/master/include/boost/applicat...

Nick Stokes

8:22 p.m.

New subject: [fusion][?] a dictionary with compile time (or types as) keys

Hi Vicente, On Mon, Feb 17, 2014 at 1:22 PM, Vicente J. Botet Escriba < vicente.botet@wanadoo.fr> wrote:

...

...
Hi,

we have added to Boost.Application a class aspect_map [1] that is quite close to your expectations. It could be proposed independently.

This looks very interesting. So, afaict, the mapping hinges on a type id csbl::type_index. Is this some kind of a std::type_info?

...

There is also a Boost.Mixin proposal that could help also.

Thanks, I'll have a look at this. (this: https://github.com/iboB/boost.mixin ?)

3919

Age (days ago)

3920

Last active (days ago)

List overview

Download

5 comments

4 participants

participants (4)

Gordon Woodhull
Larry Evans
Nick Stokes
Vicente J. Botet Escriba