vicente.botet wrote:
Two comments (for now):
1) It's not uncommon that conversion to a "To" type from a "From" type needs more information than just an instance of a From. One example would be when dynamic memory allocation is necessary to construct the To type, e.g., when converting from a boost::array to a std::vector.
How do you know the To to which do you want to convert, if not given explictly?
It is given explicitly.
In my application, I have to "upgrade" (i.e., convert) extended-but-fixed precision floats (which are statically allocated) to arbitrary precision floats (which are dynamically allocated), and the allocator_type of the arbitrary precision float shouldn't generally be default-constructed. I've worked around this by requiring my generic convert function to take a ConvertPolicy parameter (defaulted to some empty struct null_convert_policy_t), whose interpretation is up to the particular overload chosen for the conversion. I wouldn't mind seeing a better system in place. Have you considered this situation?
I'm interested on seen how you have solved the problem you found. and please could you post your example and show why it can not be specialized with the proposed convert_to or assign_to interface? Non conforming use case will improve the final library.
I use overloads of the following signature: template< class From, class To, class ConvertPolicy > To convert(const From& from, type_tag<To>, const ConvertPolicy& convert_policy) struct type_tag is just an empty struct used to avoid having to provided the "To" template parameter explicitly. I thought maybe a function signature which didn't require explicit template parameters to call might be more ADL-friendly, but admittedly I have nothing to back this up with... For (one of) my specific use cases, I need to convert among user-defined numeric types, some of which are statically allocated and some of which are dynamically allocated. Or even a conversion from double to some dynamically-allocated numeric type might be desired. Either way, converting to a dynamically-allocated numeric type (think an arbitrary-precision rational) needs an allocator to construct it, so how would you convert a double to an arbitrary_precision_rational< T, allocator_type > without additionally providing an instance of allocator_type? To get around this issue, I ultimately pass an instance of the allocator_type as the ConvertPolicy parameter, and it is interpreted appropriately by the specific overload that implements the conversion from double to arbitrary_prec...< T, allocator_type >. Of course, this begs the question: How does the code that calls "convert" know to pass allocator_type as the ConvertPolicy? It generally doesn't, of course, so it also needs to be provided a ConvertPolicy parameter by *its* client. At some point up the call hierarchy (even if this has to be at main scope), it is known what family of types one needs to convert among, hence the appropriate ConvertPolicy would be known and initiated then. Is that an adequate explanation?
2) Assuming I understand the Conversion library correctly, what are the advantages to using both overloading via ADL and function template specialization as opposed to just the former? I'm not familiar of any other free functions used in boost (or anywhere else, for that matter) that rely on (perhaps I should say "allow"?) function template specialization, so I'm wondering what the motivation and pros/cons are (cons other than compiler support). I would guess that function template specializations must reside in the same namespace as the primary template...?
The single think I can answer is that the same question is already on the documentation, unfortuantley with no answer. The answer I can give you now is that I don't master ADL to the point of using it to imlement what I have in mind. I'm unable to saying you if this is possible or not. The question of using partial specializations of template functions is for the moment secondary, if there is a better way to achieve the same goal. My main concern is if we need the generic functions convert_to and assign_to. If this can be implemented in a better way using only ADL, we could do this way. Of course I'm intersted in knowing how this can be implemented using only ADL, even if this is evident for most of you.
This is definitely a problem that needs to be solved (correctly) in a generic fashion, so I'll try to follow your progress.
I'm open to any sugestion. If we can implement it using only ADL, I will do it once I'll know how.
You might want to read Herb Sutter's GotW articles on ADL, linked from Wikipedia: http://en.wikipedia.org/wiki/Argument_dependent_name_lookup
BTW, can we add functions on the 'std' namespace?
I've got the feeling that this is generally frowned upon, but not sure... :/
Thanks for your comments and questions, Vicente
No problem. - Jeff