Small issues in docs

[c42f]

Hi, interesting to set yet another take on this problem :)

I had a look at the docs out of curiosity and have a few comments (maybe I am
just expecting too much, since this library seems to be only a few hours old!)

Support for user-defined types

I wanted to see how you achieved this, but I can't see that it works as
expected. For instance, the following is a compile error:

format::Print("a string: {0}\n") << std::string("asdf");

I thought about implementing positional arguments in tinyformat, and the best
solution I came up with involved a type of variant class as follows:

class Arg
{
    public:
        virtual void print(std::ostream& out) = 0;
};

template<typename T>
class ArgT : public Arg
{
    const T& m_value;
    public:
        virtual void print(std::ostream& out)
        {
            out << m_value;
        }
};

You'd then construct a std::vector<Arg*> as you sweep through the arguments,
creating an ArgT for the Nth argument. (The could be stack-allocated
in the tinyformat case, though unfortunately not with the << based interface.)
Reordering can then be achived simply using indexing.

In the end I didn't do it because I didn't need the functionality and it would
introduce some extra complexity to tinyformat, which is alreay a lot less tiny
than I would like ;-) It also means a virtual function call per argument which
is less than ideal...

i18n in printf
posix printf does have a notation to support positional arguments for i18n,
and this is implemented in glibc even though it's not in C99. For example,
try out:

printf("%2$s  %1$s\n", "first_arg", "second_arg");

Good luck with your implementation!
~Chris

[vitaut]

Thank you for looking at my library and for your comments.

The documentation was a bit ahead of implementation.
I've just added support both for user-defined types (UDT) and for std::string.
For supporting UDTs I implemented a simple idea very similar to yours, the only
difference is that I use a pointer to a (member) function instead of an object with
a virtual function:

template <typename T>
void Formatter::FormatCustomArg(const void *arg) {
    const T &value = *static_cast<const T*>(arg);
    // format value using iostreams and append to the buffer.
}

I plan to add support for user-provided formatting functions which could be more
efficient than the current method by working directly with the output buffer and
could also take format specifications. Another way to improve the current method
is to implement an output stream that writes directly to the buffer and use it instead
of std::ostringstream.

I corrected a section about printf mentioning the POSIX extension that adds
positional arguments.

Thanks,
Victor

[c42f]

Right, I couldn't help thinking more about the reordering problem and came to
the same conclusion: a list of pointer to template functions and void*
arguments would work nicely. I'm very tempted to implement it in tinyformat and
measure the overhead vs not reordering.

The idea of wrapping your buffer_ up in a std::streambuf and using that
instead of the stringstream also sounds good.