Re: [boost] [foreach] cheap_copy crisis?

From: Eric Niebler (eric_at_[hidden])
Date: 2005-12-05 18:53:03

MB wrote:
> 
> Errata:
> 
>    But I think about the case that my ranges which are customized as 'cheap_copy'
>    becomes base classes of anyone else.
> 
>    replaces:
> 
>      >But I think about the case that my ranges which are customized as 'cheap_copy'
>      >are derived from anyone else.
> 
> English is as difficult as C++ :-)
> 
>>>Now that 'has_cheap_copy' becomes one of the requirements of Range-concepts, doesn't it?
>>
>>No. Boost.Range defines the range concept, and FOREACH works correctly 
>>with any type that satisfies that concept. has_cheap_copy is nothing 
>>more than an optimization hint to the BOOST_FOREACH macro. It is not 
>>required and it doesn't change the meaning of anything.
> 
> 
> But the hint expands to the derived classes and
> the derived classes "must" customize 'has_cheap_copy'.

I agree that's not good. I've reimplemented the has_cheap_copy 
customization point again. See below.

> 
>>>In general, do we have the safe way of telling whether or not a type
>>>is cheap to copy without metafunctions?
>>
>>No.
> 
> 
> Is it portability-issue the reason why you avoid metafunctions?

You mean, why isn't there a has_cheap_copy<T> trait? I had originally 
wanted the cheap_copy optimization to automatically apply to derived 
types, which is the reason for the particular form of the customization 
point. I no longer think that's a good idea, so I can now add a 
has_cheap_copy<> trait, however ...

... on compilers without partial template specialization, there isn't a 
good way of saying that for all types T, boost::iterator_range<T> is 
cheap to copy. So the free function template is still the way to go on 
those compilers.

Here is the new-and-improved(-and-please-god-let-this-be-the-last) way 
to optimize FOREACH for cheap-to-copy types:

- For a user-defined range type Foo that is cheap to copy,
   you should specialize has_cheap_copy<> in the boost::foreach
   namespace, as:

     namespace boost { namespace foreach {
       template<>
       struct has_cheap_copy<Foo> : mpl::true_ {};
     }}

- For maximum portability, you could achieve the same effect
   by overloaded boost_foreach_has_cheap_copy() at global scope
   like this:

     inline boost::mpl::true_ *
     boost_foreach_has_cheap_copy(Foo *&, boost::foreach::tag)
     { return 0; }

(The slightly strange Foo *& type prevents this overload from being 
selected for types derived from Foo.)

By default FOREACH defines overloads to recognize std::pair<T,T>, 
iterator_range<T> and sub_range<T> as cheap-to-copy, but NOT types 
derived from them.

I hope this is satisfactory.

-- 
Eric Niebler
Boost Consulting
www.boost-consulting.com