vtkStringFormatter.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
// SPDX-License-Identifier: BSD-3-Clause
#ifndef vtkStringFormatter_h
#define vtkStringFormatter_h

#include "vtkCharConvCompatibility.h" // For std::chars_format, std::to_chars_result
#include "vtkCommonCoreModule.h"      // For export macro
#include "vtkLogger.h"                // For vtkLogF

#include "vtk_fmt.h" // For fmt
// clang-format off
#include VTK_FMT(fmt/args.h)    // For fmt's args
#include VTK_FMT(fmt/chrono.h)  // For fmt's chrono
#include VTK_FMT(fmt/compile.h) // For fmt's compile
#include VTK_FMT(fmt/format.h)  // For fmt's format
#include VTK_FMT(fmt/ranges.h)  // For fmt's ranges
// clang-format on

#include <string>      // For std::string
#include <string_view> // For std::string_view

namespace vtk
{
VTK_ABI_NAMESPACE_BEGIN

template <typename T,
  typename = std::enable_if_t<std::is_integral_v<T> && !std::is_same_v<T, bool>>>
VTK_ALWAYS_INLINE auto to_chars(
  char* first, char* last, const T& value, int base = 10) -> std::to_chars_result
{
  const std::size_t buffer_size = std::distance(first, last);
  if (buffer_size == 0)
  {
    return { first, std::errc::value_too_large };
  }
  const std::size_t buffer_size_1 = buffer_size - 1;
  fmt::format_to_n_result<char*> result;
  switch (base)
  {
    case 2:
      result = fmt::format_to_n(first, buffer_size_1, FMT_COMPILE("{:b}"), value);
      break;
    case 8:
      result = fmt::format_to_n(first, buffer_size_1, FMT_COMPILE("{:o}"), value);
      break;
    case 16:
      result = fmt::format_to_n(first, buffer_size_1, FMT_COMPILE("{:x}"), value);
      break;
    case 10:
    default:
      result = fmt::format_to_n(first, buffer_size_1, FMT_COMPILE("{:d}"), value);
  }
  if (result.size >= buffer_size_1)
  {
    return { first + buffer_size_1, std::errc::value_too_large };
  }
  *result.out = '\0';                 // Null-terminate
  return { result.out, std::errc{} }; // Success
}
template <typename T, typename = std::enable_if_t<std::is_floating_point_v<T>>>
VTK_ALWAYS_INLINE auto to_chars(
  char* first, char* last, const T& value, std::chars_format format) -> std::to_chars_result
{
  const std::size_t buffer_size = std::distance(first, last);
  if (buffer_size == 0)
  {
    return { first, std::errc::value_too_large };
  }
  const std::size_t buffer_size_1 = buffer_size - 1;
  fmt::format_to_n_result<char*> result;
  switch (format)
  {
    case std::chars_format::scientific:
      result = fmt::format_to_n(first, buffer_size_1, FMT_COMPILE("{:e}"), value);
      break;
    case std::chars_format::fixed:
      result = fmt::format_to_n(first, buffer_size_1, FMT_COMPILE("{:f}"), value);
      break;
    case std::chars_format::hex:
      result = fmt::format_to_n(first, buffer_size_1, FMT_COMPILE("{:a}"), value);
      break;
    case std::chars_format::general:
    default:
      result = fmt::format_to_n(first, buffer_size_1, FMT_COMPILE("{:g}"), value);
  }
  if (result.size >= buffer_size_1)
  {
    return { first + buffer_size_1, std::errc::value_too_large };
  }
  *result.out = '\0';                 // Null-terminate
  return { result.out, std::errc{} }; // Success
}
template <typename T, typename = std::enable_if_t<std::is_floating_point_v<T>>>
VTK_ALWAYS_INLINE auto to_chars(char* first, char* last, const T& value, std::chars_format format,
  int precision) -> std::to_chars_result
{
  const std::size_t buffer_size = std::distance(first, last);
  if (buffer_size == 0)
  {
    return { first, std::errc::value_too_large };
  }
  const std::size_t buffer_size_1 = buffer_size - 1;
  fmt::format_to_n_result<char*> result;
  switch (format)
  {
    case std::chars_format::scientific:
      result = fmt::format_to_n(first, buffer_size_1, FMT_COMPILE("{:.{}e}"), value, precision);
      break;
    case std::chars_format::fixed:
      result = fmt::format_to_n(first, buffer_size_1, FMT_COMPILE("{:.{}f}"), value, precision);
      break;
    case std::chars_format::hex:
      result = fmt::format_to_n(first, buffer_size_1, FMT_COMPILE("{:.{}a}"), value, precision);
      break;
    case std::chars_format::general:
    default:
      result = fmt::format_to_n(first, buffer_size_1, FMT_COMPILE("{:.{}g}"), value, precision);
  }
  if (result.size >= buffer_size_1)
  {
    return { first + buffer_size_1, std::errc::value_too_large };
  }
  *result.out = '\0';                 // Null-terminate
  return { result.out, std::errc{} }; // Success
}

// Create a macro that evaluates the result of to_chars, checks for errors, and executes a command
#define VTK_TO_CHARS_RESULT_IF_ERROR_COMMAND(to_chars_result, value, command)                      \
  switch (to_chars_result.ec)                                                                      \
  {                                                                                                \
    case std::errc::invalid_argument:                                                              \
    {                                                                                              \
      vtkLogF(ERROR, "The given argument was invalid, failed to get the converted " #value ".");   \
      command;                                                                                     \
    }                                                                                              \
    case std::errc::value_too_large:                                                               \
    {                                                                                              \
      vtkLogF(ERROR, "The given buffer was too small, failed to get the converted " #value ".");   \
      command;                                                                                     \
    }                                                                                              \
    default:                                                                                       \
    {                                                                                              \
    }                                                                                              \
  }
// Create a macro that evaluates the result of to_chars, checks for errors, and breaks
#define VTK_TO_CHARS_RESULT_IF_ERROR_BREAK(to_chars_result, value)                                 \
  VTK_TO_CHARS_RESULT_IF_ERROR_COMMAND(to_chars_result, value, break)
// Create a macro that evaluates the result of to_chars, checks for errors, and returns a value
#define VTK_TO_CHARS_RESULT_IF_ERROR_RETURN(to_chars_result, value, returnValue)                   \
  VTK_TO_CHARS_RESULT_IF_ERROR_COMMAND(to_chars_result, value, return returnValue)

using fmt::to_string;

using fmt::formatted_size;

using fmt::runtime;

using fmt::format;

#define VTK_FORMAT_IF_ERROR_COMMAND(formatCommand, command)                                        \
  try                                                                                              \
  {                                                                                                \
    formatCommand;                                                                                 \
  }                                                                                                \
  catch (const std::exception& e)                                                                  \
  {                                                                                                \
    vtkLog(ERROR, "Formatting error: " << e.what());                                               \
    command;                                                                                       \
  }                                                                                                \
  static_assert(true)
#define VTK_FORMAT_IF_ERROR_RETURN(formatCommand, returnValue)                                     \
  VTK_FORMAT_IF_ERROR_COMMAND(formatCommand, return returnValue)
#define VTK_FORMAT_IF_ERROR_BREAK(formatCommand) VTK_FORMAT_IF_ERROR_COMMAND(formatCommand, break)

using fmt::format_to_result;

using fmt::format_to;

using fmt::format_to_n_result;

using fmt::format_to_n;

using fmt::print;

using fmt::println;

VTKCOMMONCORE_EXPORT bool is_printf_format(const std::string& format);

VTKCOMMONCORE_EXPORT std::string printf_to_std_format(const std::string& printf_format);

VTKCOMMONCORE_EXPORT std::string to_std_format(const std::string& format);

VTK_ABI_NAMESPACE_END
}

#endif // vtkStringFormatter_h
// VTK-HeaderTest-Exclude: vtkStringFormatter.h