literal.hpp

 
namespace Detail::LoggerLiteral
{
enum class Frontend : uint8_t
{
  Auto,    
  Format,  
  Printf,  
};
 
enum class Resolution : uint8_t
{
  None,       
  Format,     
  Printf,     
  Ambiguous,  
};
 
template <Print::Text Source>
[[nodiscard]] consteval bool UsesFormatSyntax()
{
  for (size_t i = 0; i < Source.Size(); ++i)
  {
    if (Source.data[i] == '{' || Source.data[i] == '}')
    {
      return true;
    }
  }
  return false;
}
 
template <Print::Text Source>
[[nodiscard]] consteval bool UsesPrintfSyntax()
{
  for (size_t i = 0; i < Source.Size(); ++i)
  {
    if (Source.data[i] == '%')
    {
      return true;
    }
  }
  return false;
}
 
template <Print::Text Source>
[[nodiscard]] consteval bool FormatSourceValid()
{
  return Print::Detail::FormatFrontend::Analyze<Source>().error ==
         Print::Detail::FormatFrontend::Error::None;
}
 
template <Print::Text Source>
[[nodiscard]] consteval bool PrintfSourceValid()
{
  return Print::Detail::PrintfCompile::Analyze<Source>().error ==
         Print::Printf::Error::None;
}
 
template <Print::Text Source, typename... Args>
[[nodiscard]] consteval bool FormatMatches()
{
  if constexpr (!FormatSourceValid<Source>())
  {
    return false;
  }
  else
  {
    return LibXR::Format<Source>::template Matches<Args...>();
  }
}
 
template <Print::Text Source, typename... Args>
[[nodiscard]] consteval bool PrintfMatches()
{
  if constexpr (!PrintfSourceValid<Source>())
  {
    return false;
  }
  else
  {
    return Print::Printf::template Matches<Source, Args...>();
  }
}
 
template <Frontend Forced, Print::Text Source, typename... Args>
[[nodiscard]] consteval Resolution ResolveFrontend()
{
  constexpr bool format_match = FormatMatches<Source, Args...>();
  constexpr bool printf_match = PrintfMatches<Source, Args...>();
 
  if constexpr (Forced == Frontend::Format)
  {
    return format_match ? Resolution::Format : Resolution::None;
  }
  else if constexpr (Forced == Frontend::Printf)
  {
    return printf_match ? Resolution::Printf : Resolution::None;
  }
  else if constexpr (format_match && !printf_match)
  {
    return Resolution::Format;
  }
  else if constexpr (!format_match && printf_match)
  {
    return Resolution::Printf;
  }
  else if constexpr (!format_match && !printf_match)
  {
    return Resolution::None;
  }
  else
  {
    constexpr bool format_uses_syntax = UsesFormatSyntax<Source>();
    constexpr bool printf_uses_syntax = UsesPrintfSyntax<Source>();
 
    if constexpr (format_uses_syntax && !printf_uses_syntax)
    {
      return Resolution::Format;
    }
    else if constexpr (!format_uses_syntax && printf_uses_syntax)
    {
      return Resolution::Printf;
    }
    else if constexpr (!format_uses_syntax && !printf_uses_syntax)
    {
      return Resolution::Format;
    }
    else
    {
      return Resolution::Ambiguous;
    }
  }
}
 
template <Frontend Forced, Print::Text Source, typename... Args>
[[nodiscard]] consteval Frontend SelectFrontend()
{
  constexpr auto resolution = ResolveFrontend<Forced, Source, Args...>();
 
  if constexpr (Forced == Frontend::Format)
  {
    static_assert(
        resolution == Resolution::Format,
        "LibXR::Logger: XR_FMT(...) literal is not accepted by the brace frontend");
    return Frontend::Format;
  }
  else if constexpr (Forced == Frontend::Printf)
  {
    static_assert(
        resolution == Resolution::Printf,
        "LibXR::Logger: XR_PRINTF(...) literal is not accepted by the printf frontend");
    return Frontend::Printf;
  }
  else if constexpr (resolution == Resolution::Format)
  {
    return Frontend::Format;
  }
  else if constexpr (resolution == Resolution::Printf)
  {
    return Frontend::Printf;
  }
  else if constexpr (resolution == Resolution::Ambiguous)
  {
    static_assert(resolution != Resolution::Ambiguous,
                  "LibXR::Logger: literal is ambiguous between brace and printf "
                  "frontends; use XR_FMT(...) or XR_PRINTF(...)");
    return Frontend::Auto;
  }
  else
  {
    static_assert(resolution != Resolution::None,
                  "LibXR::Logger: literal matches neither brace nor printf frontend");
    return Frontend::Auto;
  }
}
}  // namespace Detail::LoggerLiteral