The template< namespace> construct

2 days ago, I've discovered an interesting technique, which is equivalent to the
template< namespace> construct.

I will first show you an example, because talking about concepts combined with templates is kind of rough ;)

The need

I have a function 'write' - that can be overloaded for different types.
I have 3 namespaces in which this resides - and on each namespace, the meaning of 'write' is completely different:

• prepend - prepends a string
• append - appends a string
• modify - modifies a string

I have several functors which get the namespace as template argument, and then call the write function. So what I want is something like this:

template< namespace convert = prepend>
struct write_time {
template
void operator()(const msg_type & msg) {
...
convert::write(msg, src);
}
};

Why template< namespace> ?

Of course, it would be easy to have the same concept as a template< class>. However, I want other libs/client code to be able to overload my function, and my functor classes to still have the same default (convert_format::prepend).

The construct

The solutions is simple: just defer to a class which forwards to your namespace:

namespace convert_format {
namespace prepend {
void write(const string_type & src, string & dest) {
dest.insert( dest.begin(), src.begin(), src.end() );
}
template< class string> void write(const string_type & src, cache_string_one_str<> & dest) {
dest.prepend_string(src);
}
...
}}

struct do_convert_format {
struct prepend {
template< class string>
void write(const string_type & src, string & dest) {
convert_format::prepend::write(src, dest);
}
};

struct append { ... };
struct modify { ... };
};


When implementing my functor classes, I just use:

template< class convert = do_convert_format::prepend>
struct write_time { ... };


I've used this in my Boost Logging Lib v2 : here.

I'm sure someone has used this before. Is it documented anywhere else?