format_surface.hpp

#pragma once
 
#include <cstddef>
#include <tuple>
#include <type_traits>
#include <utility>
 
#include "format_frontend_detail.hpp"
#include "writer.hpp"
 
namespace LibXR
{
template <Print::Text Source>
class Format
{
 private:
  using SourceError = Print::Detail::FormatFrontend::Error;
  inline static constexpr auto source_analysis =
      Print::Detail::FormatFrontend::Analyze<Source>();
 
  static_assert(source_analysis.error != SourceError::NumberOverflow,
                "LibXR::Format: index, width, or precision is too large");
  static_assert(source_analysis.error != SourceError::UnexpectedEnd,
                "LibXR::Format: unexpected end of format string");
  static_assert(source_analysis.error != SourceError::EmbeddedNul,
                "LibXR::Format: embedded NUL bytes are not supported in the format literal");
  static_assert(source_analysis.error != SourceError::UnmatchedBrace,
                "LibXR::Format: unmatched brace in format string");
  static_assert(source_analysis.error != SourceError::MixedIndexing,
                "LibXR::Format: automatic and manual argument indexing cannot be mixed");
  static_assert(source_analysis.error != SourceError::ManualIndexingDisabled,
                "LibXR::Format: explicit argument indexing is disabled in the current profile");
  static_assert(source_analysis.error != SourceError::DynamicField,
                "LibXR::Format: dynamic width and precision are not supported");
  static_assert(source_analysis.error != SourceError::InvalidArgumentIndex,
                "LibXR::Format: invalid argument index");
  static_assert(source_analysis.error != SourceError::InvalidSpecifier,
                "LibXR::Format: invalid format specifier");
  static_assert(source_analysis.error != SourceError::InvalidPresentation,
                "LibXR::Format: invalid presentation type");
 
 public:
  using Error = Print::Detail::FormatFrontend::Error;
 
  template <typename... Args>
  using Compiler = Print::Detail::FormatFrontend::Compiler<Source, Args...>;
 
  template <typename... Args>
  struct Compiled
  {
   private:
    using Frontend = Compiler<Args...>;
    inline static constexpr auto result = Print::FormatCompiler<Frontend>::Compile();
 
    static_assert(source_analysis.error != SourceError::None ||
                      sizeof...(Args) == source_analysis.required_argument_count,
                  "LibXR::Format: call-site argument count does not match the "
                  "referenced replacement fields");
    static_assert(result.compile_error != Error::NumberOverflow,
                  "LibXR::Format: index, width, or precision is too large");
    static_assert(result.compile_error != Error::UnexpectedEnd,
                  "LibXR::Format: unexpected end of format string");
    static_assert(result.compile_error != Error::EmbeddedNul,
                  "LibXR::Format: embedded NUL bytes are not supported in the format literal");
    static_assert(result.compile_error != Error::UnmatchedBrace,
                  "LibXR::Format: unmatched brace in format string");
    static_assert(result.compile_error != Error::MixedIndexing,
                  "LibXR::Format: automatic and manual argument indexing cannot be mixed");
    static_assert(result.compile_error != Error::ManualIndexingDisabled,
                  "LibXR::Format: explicit argument indexing is disabled in the current profile");
    static_assert(result.compile_error != Error::DynamicField,
                  "LibXR::Format: dynamic width and precision are not supported");
    static_assert(result.compile_error != Error::InvalidArgumentIndex,
                  "LibXR::Format: invalid argument index");
    static_assert(result.compile_error != Error::InvalidSpecifier,
                  "LibXR::Format: invalid format specifier");
    static_assert(result.compile_error != Error::InvalidPresentation,
                  "LibXR::Format: invalid presentation type");
    static_assert(result.compile_error != Error::MissingArgument,
                  "LibXR::Format: referenced argument index is out of range");
    static_assert(result.compile_error != Error::ArgumentTypeMismatch,
                  "LibXR::Format: format options are incompatible with the selected argument type");
    static_assert(result.compile_error != Error::UnsupportedArgumentType,
                  "LibXR::Format: unsupported C++ argument type");
    static_assert(result.compile_error != Error::TextOffsetOverflow,
                  "LibXR::Format: text pool offset is too large");
    static_assert(result.compile_error != Error::TextSizeOverflow,
                  "LibXR::Format: text span is too large");
 
   public:
    inline static constexpr auto codes = result.codes;
    inline static constexpr Print::FormatProfile profile = result.profile;
 
    [[nodiscard]] static constexpr auto ArgumentList()
    {
      return result.arg_info;
    }
 
    [[nodiscard]] static constexpr auto ArgumentOrder()
    {
      return source_analysis.argument_order;
    }
 
    [[nodiscard]] static constexpr const auto& Codes()
    {
      return codes;
    }
 
    [[nodiscard]] static constexpr Print::FormatProfile Profile()
    {
      return profile;
    }
 
    template <typename... Actual>
    [[nodiscard]] static consteval bool Matches()
    {
      return std::is_same_v<std::tuple<std::remove_cvref_t<Actual>...>,
                            std::tuple<Args...>>;
    }
  };
 
  [[nodiscard]] static constexpr size_t ArgumentCount()
  {
    return source_analysis.required_argument_count;
  }
 
  template <typename... Args>
  [[nodiscard]] static consteval bool Matches()
  {
    if constexpr (sizeof...(Args) != source_analysis.required_argument_count)
    {
      return false;
    }
    else
    {
      using Frontend = Compiler<std::remove_cvref_t<Args>...>;
      return Print::FormatCompiler<Frontend>::Compile().compile_error == Error::None;
    }
  }
 
  template <Print::OutputSink Sink, typename... Args>
  [[nodiscard]] ErrorCode WriteTo(Sink& sink, Args&&... args) const
  {
    using Built = Compiled<std::remove_cvref_t<Args>...>;
    return Print::Writer::template RunArgumentOrder<Sink, Built, Built::ArgumentOrder()>(
        sink, Built{}, std::forward<Args>(args)...);
  }
};
}  // namespace LibXR
 
namespace LibXR::Print
{
template <Text Source, OutputSink Sink, typename... Args>
[[nodiscard]] inline ErrorCode Write(Sink& sink, const LibXR::Format<Source>&,
                                     Args&&... args)
{
  using Built =
      typename LibXR::Format<Source>::template Compiled<std::remove_cvref_t<Args>...>;
  return Writer::template RunArgumentOrder<Sink, Built, Built::ArgumentOrder()>(
      sink, Built{}, std::forward<Args>(args)...);
}
}  // namespace LibXR::Print