boost::format and custom printing a std containers

Question

I have a function in my namespace ns that helps me print STL containers. For example:

template 
std::ostream& operator<         


        

Answer 1

The solution I actually went with is quite similar to Answeror's, but it works for anything:

namespace ns
{

template <typename T>
class FormatWrapper
{
public:
    explicit FormatWrapper(const T& x) :
            ref(x)
    { }

    friend std::ostream& operator<<(std::ostream& stream,
                                    const FormatWrapper<T>& self
                                   )
    {
        // The key is that operator<< is name lookup occurs inside of `ns`:
        return stream << self.ref;
    }
private:
    const T& ref;
};

template <typename T>
FormatWrapper<T> Formatable(const T& x)
{
    return FormatWrapper<T>(x);
}

}

So usage is:

boost::format("%1%") % Formatable(x);

Answer 2

The problem as already noted is because of ADL (argument dependent lookup - often attributed to Andrew Koenig, but I believe he shouldn't get all the blame).

Even in your local context it wouldn't work in a template function where you intend to use your operator<<.

One cheating trick is to put the operator<< you define into namespace std. That is verboten, but it might work in your case, but only if it is put before its usage and that might be the problem.

There might be further options, such as defining your own Set template. I experimented with

    template<typename T> using Set=std::set<T>;

but couldn't get a solution that worked without the

    using np::operator<<;

yuyoyuppe provided.

Answer 3

You can try something like this:

namespace boost // or __gnu_cxx
{
    using np::operator<<;
}
#include <boost/format/feed_args.hpp>

Answer 4

I think the most clean way is to provide a thin wrapper in your own namespace for each of the operators you want to override. For your case, it can be:

namespace ns
{
    namespace wrappers
    {
        template<class T>
        struct out
        {
            const std::set<T> &set;

            out(const std::set<T> &set) : set(set) {}

            friend std::ostream& operator<<(std::ostream& stream, const out &o)
            {
                stream << "{";
                bool first = true;
                for (const T& item : o.set)
                {
                    if (!first)
                        stream << ", ";
                    else
                        first = false;
                    stream << item;
                }
                stream << "}";
                return stream;
            }
        };
    }

    template<class T>
    wrappers::out<T> out(const std::set<T> &set)
    {
        return wrappers::out<T>(set);
    }
}

Then use it like this:

std::cout << boost::format("%1%") % ns::out(x);