DynStrPrintf.hpp

#if DO_USE_TEMPLATES==1

    // To be included from DynStr.h 

    // This provides a convenient way of formatting strings (also type safe)
    // from inside plugins:
    //
    //     DynStr& ds = ...; 
    //     ds.Printf( "Your name is %s. You're older than %d years. Address: %p\n", (const char*)name, (int)years, &ds );

    // Taking up position of unused argument.
    struct DS_NoArg{ DS_NoArg(){ } };
    
    DynStr& AppendArg( DS_NoArg dsna, const char *fmt=NULL ){ 
        // Do nothing 
        return *this;
    }

    // Generic appending Printf function with a formatting string and typed args. 
    template<class A1, class A2, class A3, class A4>
    DynStr& PrintfAppend( int& len, const char* fmt, A1 a1, A2 a2, A3 a3, A4 a4 ){
        if( !fmt || !*fmt ) { len=0; return *this; }
        
        const char* pcnt = strchr(fmt,'%');
        int len_prv = Length();
        if( !pcnt ){ Append(fmt); len=Length()-len_prv; return *this; }
        
        // Insert up to percent sign 
        Insert( STR_AT_END, fmt, pcnt-fmt );
        int len_lead = Length()-len_prv;
        const char* arg_fmt_end = pcnt+1;
        if( *arg_fmt_end=='%' ){
            Append( '%' );
            PrintfAppend(len, pcnt+2, a1, a2, a3, a4);
            len += len_lead + 1;
            return *this;
        }
        
        // Have beginning of arg formatting string. Parse to end of it.
        // Skip all modifiers.
        while( strchr(" -+0123456789.#",*arg_fmt_end) )
            arg_fmt_end++;
        // Should have a type specifier at end
        if( !strchr("cdiEfgGosupxX",*arg_fmt_end) )   // 'n' - complications
            return *this;
        arg_fmt_end++;
        
        char fmt_buf[64];
        int fmt_len = arg_fmt_end-pcnt;
        if( fmt_len>63 ) return *this;
        strncpy(fmt_buf,pcnt,fmt_len); 
        fmt_buf[fmt_len]=0;

        AppendArg( a1, fmt_buf );
        PrintfAppend( len, arg_fmt_end, a2, a3, a4, DS_NoArg() );
        len = Length()-len_prv;
        
        return *this;
    }

    // C++ provides no way of deducting types for unused parameters, so 
    // we have tp provide individual overloads for 1,2,3,4 arguments. 
    // (This is different in C++0x)
    // One arg version
    template<class A1>
    DynStr& PrintfAppend( int& len, const char* fmt, A1 a1 ){ return PrintfAppend(len,fmt,a1,  DS_NoArg(),DS_NoArg(),DS_NoArg() ); }

    // Two arg version
    template<class A1, class A2>
    DynStr& PrintfAppend( int& len, const char* fmt, A1 a1, A2 a2 ){ return PrintfAppend(len,fmt,a1,a2, DS_NoArg(),DS_NoArg() ); }

    // Three args version
    template<class A1, class A2, class A3>
    DynStr& PrintfAppend( int& len, const char* fmt, A1 a1, A2 a2, A3 a3 ){ return PrintfAppend(len,fmt,a1,a2,a3, DS_NoArg() ); }


    // As above, but without int reference for output length
    // One arg version
    template<class A1>
    DynStr& PrintfAppend( const char* fmt, A1 a1 ){ int len; return PrintfAppend(len,fmt,a1,  DS_NoArg(),DS_NoArg(),DS_NoArg() ); }

    // Two arg version
    template<class A1, class A2>
    DynStr& PrintfAppend( const char* fmt, A1 a1, A2 a2 ){ int len; return PrintfAppend(len,fmt,a1,a2, DS_NoArg(),DS_NoArg() ); }

    // Three args version
    template<class A1, class A2, class A3>
    DynStr& PrintfAppend( const char* fmt, A1 a1, A2 a2, A3 a3 ){ int len; return PrintfAppend(len,fmt,a1,a2,a3, DS_NoArg() ); }

    // Four args version
    template<class A1, class A2, class A3, class A4>
    DynStr& PrintfAppend( const char* fmt, A1 a1, A2 a2, A3 a3, A4 a4 ){ int len; return PrintfAppend( len, fmt, a1, a2, a3, a4 ); }


    // Generic Printf function with a formatting string and typed args. 
    // As above but resets string before starting printing.

    // C++ provides no way of deducting types for unused parameters, so 
    // we have tp provide individual overloads for 1,2,3,4 arguments. 
    // (This is different in C++0x)
    // One arg version
    template<class A1>
    DynStr& Printf( int& len, const char* fmt, A1 a1 ){ Reset(); return PrintfAppend(len,fmt,a1,  DS_NoArg(),DS_NoArg(),DS_NoArg() ); }

    // Two arg version
    template<class A1, class A2>
    DynStr& Printf( int& len, const char* fmt, A1 a1, A2 a2 ){ Reset(); return PrintfAppend(len,fmt,a1,a2, DS_NoArg(),DS_NoArg() ); }

    // Three args version
    template<class A1, class A2, class A3>
    DynStr& Printf( int& len, const char* fmt, A1 a1, A2 a2, A3 a3 ){ Reset(); return PrintfAppend(len,fmt,a1,a2,a3, DS_NoArg() ); }

    // Four args version
    template<class A1, class A2, class A3, class A4>
    DynStr& Printf( int& len, const char* fmt, A1 a1, A2 a2, A3 a3, A4 a4 ){ Reset(); return PrintfAppend(len,fmt,a1,a2,a3,a4); }


    // As above, but without int reference for output length
    // One arg version
    template<class A1>
    DynStr& Printf( const char* fmt, A1 a1 ){ Reset(); int len; return PrintfAppend(len,fmt,a1,  DS_NoArg(),DS_NoArg(),DS_NoArg() ); }

    // Two arg version
    template<class A1, class A2>
    DynStr& Printf( const char* fmt, A1 a1, A2 a2 ){ Reset(); int len; return PrintfAppend(len,fmt,a1,a2, DS_NoArg(),DS_NoArg() ); }

    // Three args version
    template<class A1, class A2, class A3>
    DynStr& Printf( const char* fmt, A1 a1, A2 a2, A3 a3 ){ Reset(); int len; return PrintfAppend(len,fmt,a1,a2,a3, DS_NoArg() ); }

    // Four args version
    template<class A1, class A2, class A3, class A4>
    DynStr& Printf( const char* fmt, A1 a1, A2 a2, A3 a3, A4 a4 ){ Reset(); int len; return PrintfAppend( len, fmt, a1, a2, a3, a4 ); }
    
#endif // DO_USE_TEMPLATES==1

---