What we need is a generic range adaptor that can make a container of
containers look like a "flat" sequence.
I suggest the syntax
rngOfContainers | boost::adaptors::flattened
and the underlying iterator should be up to bidirectional (if the
underlying two container types support it).
Anyone interested in implementing this?
-Thorsten
_______________________________________________
Boost-users mailing list
Boost...@lists.boost.org
http://lists.boost.org/mailman/listinfo.cgi/boost-users
What we need is a generic range adaptor that can make a container of containers look like a "flat" sequence.
I suggest the syntax
rngOfContainers | boost::adaptors::flattened
and the underlying iterator should be up to bidirectional (if the underlying two container types support it).
Anyone interested in implementing this?
-Thorsten
> I've been interested in implementing something similar for a while. I
> was thinking slightly more generally that any n-dimensional structure
> can often be linearised or projected into a linear sequence. Hence this
> would enable not just the above example to work, but many standard
> algorithms could work with tree structures, hyper-cube trees, directed
> acyclic graphs etc. I've implemented a number of these already, but
> wanted to gain experience with them in my own projects before committing
> them to the trunk.
Cool. I have a little problem seeing how it works with acyclic graphs.
For example, there are many ways to do this. Which one do we pick?
I think the container of containers case meets 90% or more of all use
cases. A container of containers of containers can be done manually by
applying it twice.
Even trees, surely they provide some kind of iteration already?
(Like std::map/std::set). So what is special here?
> What we need is a generic range adaptor that can make a container of
> containers look like a "flat" sequence.
>
> I suggest the syntax
>
> rngOfContainers | boost::adaptors::flattened
>
> and the underlying iterator should be up to bidirectional (if the
> underlying two container types support it).
>
> Anyone interested in implementing this?
I have an implementation of this somewhere.
One annoying thing is that you cannot detect that a type is a range
reliably.
True, there are many ways to linearize a n-dimensional structure.
Consider a matrix, do you start with rows or with columns?
> I think the container of containers case meets 90% or more of all use
> cases. A container of containers of containers can be done manually by
> applying it twice.
For ranges of ranges (of ranges...), unless they're random access, I
don't think anything but linearizing in the "natural" order of iteration
makes sense.
>> I suggest the syntax
>>
>> rngOfContainers | boost::adaptors::flattened
>>
>> and the underlying iterator should be up to bidirectional (if the
>> underlying two container types support it).
>>
>> Anyone interested in implementing this?
>
> I have an implementation of this somewhere.
>
> One annoying thing is that you cannot detect that a type is a range
> reliably.
Well, that is only a problem if you want to avoid manually applying the
adaptor twice (or more), right?
If so, I think that is a limitation we can live with. A simple solution
covers most cases IMO.
-Thorsten
> Well, that is only a problem if you want to avoid manually applying the
> adaptor twice (or more), right?
>
> If so, I think that is a limitation we can live with. A simple solution
> covers most cases IMO.
Oh, the adaptor I wrote flattens recursively.
I guess just flattening the top level could be fairly easy.