finding string format specifiers of variable argument list - c++

Question

I have this Log function that call my logger (spdlog) methods :
template<typename... Args>
void Log(const char* fmt,
const Args&... args)
{
g_FileLogger->log(fmt, args...);
}
I want to change my logger (spdlog, represented by g_FileLoggre) to another logger. Unfortunately, "fmt" strings contain "{}" which are the the placeholder of variables "args". I want to change those "{}" by the correct format specifier (%s, %zu, %d etc...) as with the other loggers, I have to specify the correct format specifier.
Can you give me a quick and safe solution to generate a string that replaces "{}" by the correct format specifier of the variables.
Otherwise, spdlog is a great logging API, but since its API has been broken, we decided to choose another logger, for example in Centos the API is old whereas in Gentoo it is newer and code will not compile.

Answer 1

Create a format_converter function
template<typename... Args>
std::string format_converter(const char* fmt,
const Args&... args)
{...}
which parses the fmt string and converts it according to the arguments.
Then modify your function:
template<typename... Args>
void Log(const char* fmt,
const Args&... args)
{
auto new_fmt = format_converter(fmt, args...);
new_logger->log( new_fmt, args... );
}
Edit:
In the format_converter, template functions can be used to convert the types of parameters to strings. For example:
template< typename T >
const char* type_string( const T ); // primary template
const char* type_string( const char* ) // overload for c-string
{
return "%s";
}
template<>
const char* type_string< double >( const double ) // partial specialization for double
{
return "%d";
}
template<>
const char* type_string< int >( const int ) // partial specialization for int
{
return "%i";
}
// .....

Answer 2

Create the convert_format function that will replace {..} with what you specify. Create a std::map<std::string, std::string> object that contains the data for replacing.
#include <string>
#include <map>
std::string convert_format(const std::string& format, std::map<std::string, std::string> format_map) {
string ret;
for (int x = 0; x != format.size(); ++x) {
if (format[x] == '{') {
std::string key;
++x;
for (; x != format.size(); ++x) {
if (format[x] == '}') {
auto itr = format_map.find(key);
if (itr != format_map.end()) {
ret += (*itr).second;
}
break;
} else {
key.push_back(format[x]);
}
}
} else {
ret.push_back(format[x]);
}
}
return ret;
}
And now modifies the Log function as:
template<typename... Args>
void Log(const char* fmt,
const Args&... args)
{
// map that will contain the data.
std::map<std::string, std::string> format_map;
// IF you have an args named as number and a string
// replaces {number} with %d
format_map["number"] = "%d";
// for replacing '{string}' with %s
format_map["string"] = "%s"; // ... and so on
auto new_fmt = convert_format(std::string(fmt), format_map);
new_logger->log( new_fmt, args... );
}
EDIT: I think you need a macro that will pass name and value of the variable to the function Log.