[boost] Re: Re: Shared Container Iterator Adaptor in sandbox and filessection.

From: Gustavo Guerra (gustavobt_at_[hidden])
Date: 2002-09-05 10:56:27

"Ronald Garcia" <garcia_at_[hidden]> wrote in message
news:3D76375C.4090101_at_cs.indiana.edu...
> Gustavo Guerra wrote:
>
> >Hi
> >Have you ever looked at pointainer from http://ootips.org/yonat/4dev/ ?
> >Could you comment on the different approaches used by your library, where
> >reference-count is inforced in the iterators, and pointainer, where
> >reference-count is inforced by container-wrappers?
> >
> >
> Greetings,
>
> Having quickly browsed the sparse documentation for pointainer, it looks
> to me like our libraries are altogether different beasts.  A quick
> perusal of my documentation should clarify the difference.
>

Yes, you're right. Sorry. I got your library right, but misinterpreted
pointerator. What is was thinking pointerator was is the following, wich I
now ask you to compare to your solution:

I find it more easy to explain by an example.Your
shared_iterator_example3.cpp would become the following:

#include "boost/shared_container.hpp"
#include "boost/tuple/tuple.hpp"
#include <algorithm>
#include <iostream>
#include <vector>

typedef shared_container<std::vector<int> > ints;

std::pair<ints::iterator, ints::iterator>
return_range() {
    ints range;
    range.push_back(0);
    range.push_back(1);
    range.push_back(2);
    range.push_back(3);
    range.push_back(4);
    range.push_back(5);
    return make_pair(v.begin(); v.end());
}

int main() {
    ints::iterator i, end;
    boost::tie(i,end) = return_range();

    std::copy(i,end,std::ostream_iterator<int>(std::cout,","));
    std::cout.put('\n');
}

What do you think of this interface? It hides the shared_ptr from the user
and makes it more easy to use. Implementation-wise, it has the benefit that
you could use counted_base for intrusive reference counting, wich would be
more efficient. The corresponding iterators would include shared_ptr to the
shared container, much like your version. Of course this would be much more
harder to implement. A possible implementation would be to
shared_container<T> inherit from T and redefining all methods that return
iterators, requiring a little metaprogramming to know wich functions to
redefine depending on the type of the container.
Pros of your version: more simple and scalable. Pros of a pseudo-version
like I just described: more easy to use and maybe more efficient.

What do you think?

Regards
Gustavo Guerra