Testing for the presence of the left shift operator

boost, c++, stl, type-traits

Solution

The reason why it does not work is that C++ has sometimes surprising (but well motivated) rules for resolving a function call. In particular, name lookup is first performed in namespace where the call happens and in the namespace of the arguments (for UDTs): if a function with a matching name (or if a matching built-in operator) is found, it is selected (or if more than one are found, overload resolution is performed).

Only if no function with the matching name is found in the namespace of the arguments, the parent namespaces are checked. If a function with a matching name is found is but not viable for resolving the call, or if the call is ambiguous, the compiler will not keep looking up in parent namespaces with the hope of finding a better or unambiguous match: rather, it will conclude that there is no way to resolve the call.

This mechanism is nicely explained in this presentation by Stephan T. Lavavej and in this old article by Herb Sutter.

In your case, the function which checks for the existence of this operator is in the `boost` namespace. Your arguments are either from the `std` namespace (`ostream`, `string`, `vector`) or are PODs (`int`). In the `std` namespace, a non-viable overload of `operator <<` exist, so the compiler does not bother looking up in the parent (global) namespace, where your overload is defined. It will simply conclude that the (simulated) call done in the `boost` namespace to check whether `operator <<` is defined can't be resolved.

Now `boost::has_left_shift` is likely to have some SFINAE machinery for turning what would otherwise be a compilation error into a failed substitution, and will assign `false` to the `value` static variable.

UPDATE:

The original part of the answer explained why this does not work. Let's now see if there is a way to work around it. Since ADL is used and the `std` namespace contains a non-viable overload of `operator <<`, de facto blocking the attempt to resolve the call, one could be tempted to move the viable overloads of `operator <<` from the global namespace into the `std` namespace.

Alas, extending the `std` namespace (and this is what we would do if we were to add new overloads of `operator <<`) is forbidden by the C++ Standard. What is allowed instead is to specialize a template function defined in the `std` namespace (unless stated otherwise); however, this doesn't help us here, because there is no template whose parameters can be specialized by `vector<int>`. Moreover, function templates cannot be partially specialized, which would make things much more unwieldy.

There is one last possibility though: add the overload to the namespace where the call resolution occurs. This is somewhere inside the machinery of Boost.TypeTraits. In particular, what we are interested in is the name of the namespace in which the call is made.

In the current version of the library, that happens to be `boost::detail::has_left_shift_impl`, but I am not sure how portable this is across different Boost versions.

However, if you really need a workaround, you can declare your operators in that namespace:

namespace boost 
{ 
    namespace detail 
    { 
        namespace has_left_shift_impl
        {
            ostream& operator<<(ostream& stream, const Point& p)
            {
                stream << p.getStr();
                return stream;
            }

            template <typename T>
            std::ostream& operator<<(std::ostream& stream, const std::vector<T>& v)
            {
                stream << "[";
                for(auto it = v.begin(); it != v.end(); ++it)
                {
                    if(it != v.begin())
                        stream << ", ";
                    stream << *it;
                }
                stream << "]";
                return stream;
            }
        } 
    } 
}

And things will start working.

There is one caveat though: while this compiles and runs fine with GCC 4.7.2 with the expected output. However, Clang 3.2 seems to require the overloads to be defined in the `boost::details::has_left_shift_impl` before the `has_left_shift.hpp` header is included. I believe this is a bug.

Problem

Original source