meta.hpp

Go to the documentation of this file.

#pragma once
 
#include <ranges>
#include <sstream>
#include <string>
#include <tuple>
#include <type_traits>
#include <vector>
 
namespace relx::query {
 
template <typename Tuple>
static constexpr bool is_empty_tuple() {
  return std::tuple_size_v<Tuple> == 0;
}
 
template <typename Tuple>
std::string tuple_to_sql(const Tuple& tuple, const char* separator) {
  std::stringstream ss;
  int i = 0;
  std::apply(
      [&](const auto&... items) { ((ss << (i++ > 0 ? separator : "") << items.to_sql()), ...); },
      tuple);
  return ss.str();
}
 
template <typename Tuple>
std::vector<std::string> tuple_bind_params(const Tuple& tuple) {
  std::vector<std::string> params;
 
  std::apply(
      [&](const auto&... items) {
        auto process_item = [&params](const auto& item) {
          auto item_params = item.bind_params();
          if (!item_params.empty()) {
            params.insert(params.end(), item_params.begin(), item_params.end());
          }
        };
 
        (process_item(items), ...);
      },
      tuple);
 
  return params;
}
 
template <typename Func, typename Tuple>
static void apply_tuple(Func&& func, const Tuple& tuple) {
  std::apply([&func](const auto&... args) { (func(args), ...); }, tuple);
}
 
template <typename T>
struct class_of_t;
 
template <typename Class, typename T>
struct class_of_t<T Class::*> {
  using type = Class;
};
 
template <typename T>
using class_of_t_t = typename class_of_t<T>::type;
 
template <auto MemberPtr>
struct column_type_of {
  using table_type = class_of_t_t<decltype(MemberPtr)>;
  using column_type = std::remove_reference_t<decltype(std::declval<table_type>().*MemberPtr)>;
};
 
template <auto MemberPtr>
constexpr auto column_name_of() {
  using column_t = typename column_type_of<MemberPtr>::column_type;
  return column_t::name;
}
 
}  // namespace relx::query