Re: [Boost-users] [boost-users][Variant] Sequence instantiation

Subject: Re: [Boost-users] [boost-users][Variant] Sequence instantiation
From: OvermindDL1 (overminddl1_at_[hidden])
Date: 2009-08-27 00:39:23

On Wed, Aug 26, 2009 at 8:32 PM, Ryan McConnehey<mccorywork_at_[hidden]> wrote:
>
>> I doubt Boost.Variant is the best choice for this.  You say a template
>> function to enforce types, I would say Boost.Enable_if combined with
>> Boost.Type_traits and Boost.MPL would make it real easy.
>>
>
> I'm all for making this easy.  So, let me give you some background of what
> I'm trying to do.  I'm reading an xml file that contains a binary format
> description (lets call the class BFD).  This will allow me to specify a
> customers binary data in such a way as to place the binary data into an
> object.  Each parameter has a type associated with it.  This can be a int,
> short, string, long etc.  The class reading the xml file is storing the type
> information based on the parameter name.  Any class trying to retrieve this
> binary format description will need to specify the parameter name and
> expected type.  If the parameter name exists but the type is incorrect then
> an empty description is returned.
>
> I need to limit the types that can be requested from the BFD.  That's where
> the mpl::vector of known types comes into play.  The function returning the
> binary description information will check (at compile time) to make sure the
> type requested is part of the known types.  Since the BFD is comparing types
> I need to convert the string names of these types, in the xml file, into
> real types.  This has posed a problem.  I come up with nothing better than a
> case statement.  Once the type is known I then create a binary format
> description object (this is a template structure).  The only reason the
> structure is a template is to associate a type.  This is why I though the
> boost::variant was necessary.  A variant composed of each of the types in
> the mpl::vector was defined as the second parameter of a map with the key as
> the parameter name from the xml file.  The function returning the binary
> description information will check the type of the data stored in the map
> and if the types match then return the structure.
>
> So with this information in mind how would you use the boost::enable_if,
> boost::type_traits and boost:mpl.

Ah, I did not have enough information, in that case I would use
Boost.Variant as the container with something like Spirit2.1's string
table to do a faster type (string->type and parsing) lookup, that
would give you excellent speed for that purpose.  Something like
Boost.Fusion's map would also work as well, but which is better
depends on how much of the work is done at compile-time and how much
is done at run-time, I am not fully clear about that, I do not suppose
you could show some pseudo-code of what you want?