Use tuple in variadic template

Question

I am designing a logger. I'll format for it. I made a design that I would predetermine the format string and then keep this data in a tuple and print it to the log.

The code below is working now, but I want it to work in the parts I commented out. So, according to the default arguments I set, I want it to use the default argument if no argument is given.

NOTE: I want these processes to be at compile time.

#include <iostream>
#include <tuple>
#include <memory>
#include <type_traits>

class MyLogger {
public:
    template<typename... Args>
    void Log(const char* format, Args... args) {
        printf(format, args...);
        printf("\n");
    }
};

static inline std::unique_ptr<MyLogger> logger = std::make_unique<MyLogger>();

template<typename FMT, typename... Args>
struct LogLineDef {
    LogLineDef(Args... args) : values(args...) {}
    
    std::tuple<Args...> values;
};

constexpr char FMT1[] = "A:%d, B:%d, C:%d, D:%f ";
using L1 = LogLineDef<std::integral_constant<const char*, FMT1>, int, int, int, float>;

template<typename FMT, typename... Args>
void log_helper(const char* message, const LogLineDef<FMT, Args...>& logger_line_def) {
    std::apply([message](const auto&... args) {
        logger->Log((FMT::value + std::string(message)).c_str(), args...);
    }, logger_line_def.values);
}

#define LOG(logger_line_def, message, ...) log_helper(message, logger_line_def, ##__VA_ARGS__)

int main() {
    LOG(L1(1, 2, 3, 4.f), "error");
    //LOG(L1(1, 2, 3), "error"); // should be legal according to default value
    //LOG(L1(1, 2), "error"); // should be legal according to default value 
}

Answer 1

I implemented a solution where you can define a list of types and with labels by:

static constexpr auto L1 = LabelList<int, int, int, float>{"A", "B", "C", "D"};

If you provide less arguments they are not printed. If the provides arguments have another types then in the definition you will get a compile time error. You need to define a c_str formatter for every type you want to support by:

template <>
inline constexpr char const* c_format<int> = "%d";

Here is the full logger:

#include <cstdio>
#include <memory>
#include <sstream>
#include <string>
#include <string_view>
#include <tuple>
#include <type_traits>


class MyLogger {
public:
    void Log(std::string const& data, std::string const& message) {
        std::printf("%s %s\n", data.c_str(), message.c_str());
    }
};

static inline std::unique_ptr<MyLogger> logger = std::make_unique<MyLogger>();


template <typename T>
inline constexpr char const* c_format = "c_format missing";

template <>
inline constexpr char const* c_format<int> = "%d";

template <>
inline constexpr char const* c_format<float> = "%f";


template <typename T>
struct Label: std::string_view {
    using std::string_view::string_view;
    using type = T;
};

template <typename ... Ts, std::size_t ... Is, typename U, typename ... Us>
std::string to_string(
    std::tuple<Label<Ts> ...> const& labels,
    std::index_sequence<Is ...>,
    U&& first, Us&& ... values
) {
    static_assert(
        std::is_same_v<typename std::remove_reference_t<decltype(std::get<0>(labels))>::type, U> &&
        (std::is_same_v<typename std::remove_reference_t<decltype(std::get<Is + 1>(labels))>::type, Us> && ...));

    using namespace std;
    std::ostringstream format;
    format << std::get<0>(labels) << ": " << c_format<U>;
    ((format << ", " << std::get<Is + 1>(labels) << ": " << c_format<Us>), ...);

    auto const c_format = std::move(format).str();
    auto const lenght =std::snprintf(nullptr, 0, c_format.c_str(), first, values ...);
    std::string result(lenght, '\0');
    sprintf(result.data(), c_format.c_str(), first, values ...);
    return result;
}


template <typename ... Ts>
struct LabelList: std::tuple<Label<Ts> ...> {
    using std::tuple<Label<Ts> ...>::tuple;

    template <typename ... Us>
    std::string operator()(Us&& ... values) const {
        static_assert(sizeof...(Us) <= sizeof...(Ts));

        if constexpr (sizeof...(Us) == 0) {
            return "";
        } else {
            return to_string(*this,
                std::make_index_sequence<sizeof...(Us) - 1>(),
                std::forward<Us>(values) ...);
        }
    }
};

static constexpr auto L1 = LabelList<int, int, int, float>{"A", "B", "C", "D"};


int main() {
    logger->Log(L1(1, 2, 3, 4.f), "error");
    logger->Log(L1(1, 2, 3), "error");
    logger->Log(L1(1, 2), "error");
}

A: 1, B: 2, C: 3, D: 4.000000 error
A: 1, B: 2, C: 3 error
A: 1, B: 2 error