Boost logo

Boost :

From: Tobias Schwinger (tschwinger_at_[hidden])
Date: 2005-02-27 08:52:20

Hi Dave,

David Abrahams wrote:
> Tobias Schwinger <tschwinger_at_[hidden]> writes:
>>Tobias Schwinger wrote:
>>>What is the best way to convert the result of a mutating mpl
>>>intrinsic metafunction (such as 'mpl::push_back', for example) to
>>>numbered form ('vectorN<a1,a2,..>') ?
> I was hoping Aleksey would answer, but he seems to have dropped off
> the face of the earth (temporarily, I hope).

Thanks for your attempt to fill the (hopefully temporary) gap.

> I am guessing that Aleksey would say "don't do that!" He has always
> maintained that relying on sequence type identity was just wrong.

This, in itself, makes pretty much sense to me.

However, I need to get to the types "all at once" rather than "one at a
time" (details below).

>>>I tried using the type-member (which only works on some compilers -
>>>not with GCC for example) and figure 'copy' could probably do the
>>>trick (but is a quite complex operation) so there might be a better
>>>recipe for this.
>>>In a library I'm currently working on, I use a decorator pattern to
>>[ This refers to: ]
>>>a class model of a sequence it holds (i.e. give it a tag type member
>>>and specialize *_impl with delegate semantics). After applying the
>>>delegate metafunction I need the sequence in a form I can match with
>>>partial specialization.
> I don't know the details of your problem, so I can't say for sure, but
> you might consider using partial specialization based on the
> sequence's tag and/or size.

I am working on a library which allos to work with function types [ the
link above points to the announcement of the preview version on this
list, yesterday ].

The problem lies in the metafunction to synthesize function types from
an MPL Seuqence [ ref. class template function_type ]:

The current procedure is:

- check for the sequence tag
- if it is a vector use its ::type member
- if it is an mpl sequence, but not a vector use mpl::copy to make it
(other cases are checked for, that do not matter in this context)
- the _impl-part of the story then uses a partial specialization cascade
to extract the elements
- build the function type from them
(this works fine for non-typeof-based sequences)

Specializing by size would mean:

- use at_c for every element
- build the function type from them
(reads nicely here, but has to be done for the whole cascade,
(max_arity*kinds_of_function_types_supported) times, which would result
in an unreadable and inefficient mass of code)

Probably the latter is still the better way to go, however, I was hoping
(and still do) for a better solution than these two.

Unless you (or someone on the list) knows one, it's probably a wise idea
to just wait for Aleksey to reappear before changing things around...

Best regards,


Boost list run by bdawes at, gregod at, cpdaniel at, john at