aarch64/usr/include/c++/v1/__format/formatter.h - manifest_repos/toolchain - Git at Google

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//

 #ifndef _LIBCPP___FORMAT_FORMATTER_H
 #define _LIBCPP___FORMAT_FORMATTER_H

 #include <__algorithm/copy.h>
 #include <__algorithm/fill_n.h>
 #include <__availability>
 #include <__config>
 #include <__format/format_error.h>
 #include <__format/format_fwd.h>
 #include <__format/format_string.h>
 #include <__format/parser_std_format_spec.h>
 #include <concepts>
 #include <string_view>

 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif

 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>

 _LIBCPP_BEGIN_NAMESPACE_STD

 #if _LIBCPP_STD_VER > 17

 // TODO FMT Remove this once we require compilers with proper C++20 support.
 // If the compiler has no concepts support, the format header will be disabled.
 // Without concepts support enable_if needs to be used and that too much effort
 // to support compilers with partial C++20 support.
 #if !defined(_LIBCPP_HAS_NO_CONCEPTS)

 // Currently not implemented specializations throw an exception when used. This
 // does not conform to the Standard. However not all Standard defined formatters
 // have been implemented yet. Until that time the current behavior is intended.
 // TODO FMT Disable the default template.
 template <class _Tp, class _CharT>
 struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter {
   _LIBCPP_NORETURN _LIBCPP_HIDE_FROM_ABI auto parse(auto& __parse_ctx)
       -> decltype(__parse_ctx.begin()) {
     __throw();
   }

   _LIBCPP_NORETURN _LIBCPP_HIDE_FROM_ABI auto format(_Tp, auto& __ctx)
       -> decltype(__ctx.out()) {
     __throw();
   }

 private:
   _LIBCPP_NORETURN _LIBCPP_HIDE_FROM_ABI void __throw() {
     __throw_format_error("Argument type not implemented yet");
   }
 };

 namespace __format_spec {

 _LIBCPP_HIDE_FROM_ABI inline char* __insert_sign(char* __buf, bool __negative,
                                                  _Flags::_Sign __sign) {
   if (__negative)
     *__buf++ = '-';
   else
     switch (__sign) {
     case _Flags::_Sign::__default:
     case _Flags::_Sign::__minus:
       // No sign added.
       break;
     case _Flags::_Sign::__plus:
       *__buf++ = '+';
       break;
     case _Flags::_Sign::__space:
       *__buf++ = ' ';
       break;
     }

   return __buf;
 }

 _LIBCPP_HIDE_FROM_ABI constexpr char __hex_to_upper(char c) {
   switch (c) {
   case 'a':
     return 'A';
   case 'b':
     return 'B';
   case 'c':
     return 'C';
   case 'd':
     return 'D';
   case 'e':
     return 'E';
   case 'f':
     return 'F';
   }
   return c;
 }

 } // namespace __format_spec

 namespace __formatter {

 /** The character types that formatters are specialized for. */
 template <class _CharT>
 concept __char_type = same_as<_CharT, char> || same_as<_CharT, wchar_t>;

 struct _LIBCPP_TEMPLATE_VIS __padding_size_result {
   size_t __before;
   size_t __after;
 };

 _LIBCPP_HIDE_FROM_ABI constexpr __padding_size_result
 __padding_size(size_t __size, size_t __width,
                __format_spec::_Flags::_Alignment __align) {
   _LIBCPP_ASSERT(__width > __size,
                  "Don't call this function when no padding is required");
   _LIBCPP_ASSERT(
       __align != __format_spec::_Flags::_Alignment::__default,
       "Caller should adjust the default to the value required by the type");

   size_t __fill = __width - __size;
   switch (__align) {
   case __format_spec::_Flags::_Alignment::__default:
     _LIBCPP_UNREACHABLE();

   case __format_spec::_Flags::_Alignment::__left:
     return {0, __fill};

   case __format_spec::_Flags::_Alignment::__center: {
     // The extra padding is divided per [format.string.std]/3
     // __before = floor(__fill, 2);
     // __after = ceil(__fill, 2);
     size_t __before = __fill / 2;
     size_t __after = __fill - __before;
     return {__before, __after};
   }
   case __format_spec::_Flags::_Alignment::__right:
     return {__fill, 0};
   }
   _LIBCPP_UNREACHABLE();
 }

 /**
  * Writes the input to the output with the required padding.
  *
  * Since the output column width is specified the function can be used for
  * ASCII and Unicode input.
  *
  * @pre [@a __first, @a __last) is a valid range.
  * @pre @a __size <= @a __width. Using this function when this pre-condition
  *      doesn't hold incurs an unwanted overhead.
  *
  * @param __out_it    The output iterator to write to.
  * @param __first     Pointer to the first element to write.
  * @param __last      Pointer beyond the last element to write.
  * @param __size      The (estimated) output column width. When the elements
  *                    to be written are ASCII the following condition holds
  *                    @a __size == @a __last - @a __first.
  * @param __width     The number of output columns to write.
  * @param __fill      The character used for the alignment of the output.
  *                    TODO FMT Will probably change to support Unicode grapheme
  *                    cluster.
  * @param __alignment The requested alignment.
  *
  * @returns           An iterator pointing beyond the last element written.
  *
  * @note The type of the elements in range [@a __first, @a __last) can differ
  * from the type of @a __fill. Integer output uses @c std::to_chars for its
  * conversion, which means the [@a __first, @a __last) always contains elements
  * of the type @c char.
  */
 template <class _CharT, class _Fill>
 _LIBCPP_HIDE_FROM_ABI auto
 __write(output_iterator<const _CharT&> auto __out_it, const _CharT* __first,
         const _CharT* __last, size_t __size, size_t __width, _Fill __fill,
         __format_spec::_Flags::_Alignment __alignment) -> decltype(__out_it) {

   _LIBCPP_ASSERT(__first <= __last, "Not a valid range");
   _LIBCPP_ASSERT(__size < __width, "Precondition failure");

   __padding_size_result __padding =
       __padding_size(__size, __width, __alignment);
   __out_it = _VSTD::fill_n(_VSTD::move(__out_it), __padding.__before, __fill);
   __out_it = _VSTD::copy(__first, __last, _VSTD::move(__out_it));
   return _VSTD::fill_n(_VSTD::move(__out_it), __padding.__after, __fill);
 }

 /**
  * @overload
  *
  * Uses a transformation operation before writing an element.
  *
  * TODO FMT Fill will probably change to support Unicode grapheme cluster.
  */
 template <class _CharT, class _UnaryOperation, class _Fill>
 _LIBCPP_HIDE_FROM_ABI auto
 __write(output_iterator<const _CharT&> auto __out_it, const _CharT* __first,
         const _CharT* __last, size_t __size, _UnaryOperation __op,
         size_t __width, _Fill __fill,
         __format_spec::_Flags::_Alignment __alignment) -> decltype(__out_it) {

   _LIBCPP_ASSERT(__first <= __last, "Not a valid range");
   _LIBCPP_ASSERT(__size < __width, "Precondition failure");

   __padding_size_result __padding =
       __padding_size(__size, __width, __alignment);
   __out_it = _VSTD::fill_n(_VSTD::move(__out_it), __padding.__before, __fill);
   __out_it = _VSTD::transform(__first, __last, _VSTD::move(__out_it), __op);
   return _VSTD::fill_n(_VSTD::move(__out_it), __padding.__after, __fill);
 }

 /**
  * Writes Unicode input to the output with the required padding.
  *
  * This function does almost the same as the @ref __write function, but handles
  * the width estimation of the Unicode input.
  *
  * @param __str       The range [@a __first, @a __last).
  * @param __precision The width to truncate the input string to, use @c -1 for
  *                     no limit.
  */
 template <class _CharT, class _Fill>
 _LIBCPP_HIDE_FROM_ABI auto
 __write_unicode(output_iterator<const _CharT&> auto __out_it,
                 basic_string_view<_CharT> __str, ptrdiff_t __width,
                 ptrdiff_t __precision, _Fill __fill,
                 __format_spec::_Flags::_Alignment __alignment)
     -> decltype(__out_it) {

   // This value changes when there Unicode column width limits the output
   // size.
   auto __last = __str.end();
   if (__width != 0 || __precision != -1) {
     __format_spec::__string_alignment<_CharT> __format_traits =
         __format_spec::__get_string_alignment(__str.begin(), __str.end(),
                                               __width, __precision);

     if (__format_traits.__align)
       return __write(_VSTD::move(__out_it), __str.begin(),
                      __format_traits.__last, __format_traits.__size, __width,
                      __fill, __alignment);

     // No alignment required update the output based on the precision.
     // This might be the same as __str.end().
     __last = __format_traits.__last;
   }

   // Copy the input to the output. The output size might be limited by the
   // precision.
   return _VSTD::copy(__str.begin(), __last, _VSTD::move(__out_it));
 }

 } // namespace __formatter

 #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)

 #endif //_LIBCPP_STD_VER > 17

 _LIBCPP_END_NAMESPACE_STD

 _LIBCPP_POP_MACROS

 #endif // _LIBCPP___FORMAT_FORMATTER_H
	// -- C++ --
	//===----------------------------------------------------------------------===//
	//
	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
	// See https://llvm.org/LICENSE.txt for license information.
	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
	//
	//===----------------------------------------------------------------------===//

	#ifndef _LIBCPP___FORMAT_FORMATTER_H
	#define _LIBCPP___FORMAT_FORMATTER_H

	#include <__algorithm/copy.h>
	#include <__algorithm/fill_n.h>
	#include <__availability>
	#include <__config>
	#include <__format/format_error.h>
	#include <__format/format_fwd.h>
	#include <__format/format_string.h>
	#include <__format/parser_std_format_spec.h>
	#include <concepts>
	#include <string_view>

	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
	#pragma GCC system_header
	#endif

	_LIBCPP_PUSH_MACROS
	#include <__undef_macros>

	_LIBCPP_BEGIN_NAMESPACE_STD

	#if _LIBCPP_STD_VER > 17

	// TODO FMT Remove this once we require compilers with proper C++20 support.
	// If the compiler has no concepts support, the format header will be disabled.
	// Without concepts support enable_if needs to be used and that too much effort
	// to support compilers with partial C++20 support.
	#if !defined(_LIBCPP_HAS_NO_CONCEPTS)

	// Currently not implemented specializations throw an exception when used. This
	// does not conform to the Standard. However not all Standard defined formatters
	// have been implemented yet. Until that time the current behavior is intended.
	// TODO FMT Disable the default template.
	template <class _Tp, class _CharT>
	struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter {
	_LIBCPP_NORETURN _LIBCPP_HIDE_FROM_ABI auto parse(auto& __parse_ctx)
	-> decltype(__parse_ctx.begin()) {
	__throw();
	}

	_LIBCPP_NORETURN _LIBCPP_HIDE_FROM_ABI auto format(_Tp, auto& __ctx)
	-> decltype(__ctx.out()) {
	__throw();
	}

	private:
	_LIBCPP_NORETURN _LIBCPP_HIDE_FROM_ABI void __throw() {
	__throw_format_error("Argument type not implemented yet");
	}
	};

	namespace __format_spec {

	_LIBCPP_HIDE_FROM_ABI inline char* __insert_sign(char* __buf, bool __negative,
	_Flags::_Sign __sign) {
	if (__negative)
	*__buf++ = '-';
	else
	switch (__sign) {
	case _Flags::_Sign::__default:
	case _Flags::_Sign::__minus:
	// No sign added.
	break;
	case _Flags::_Sign::__plus:
	*__buf++ = '+';
	break;
	case _Flags::_Sign::__space:
	*__buf++ = ' ';
	break;
	}

	return __buf;
	}

	_LIBCPP_HIDE_FROM_ABI constexpr char __hex_to_upper(char c) {
	switch (c) {
	case 'a':
	return 'A';
	case 'b':
	return 'B';
	case 'c':
	return 'C';
	case 'd':
	return 'D';
	case 'e':
	return 'E';
	case 'f':
	return 'F';
	}
	return c;
	}

	} // namespace __format_spec

	namespace __formatter {

	/** The character types that formatters are specialized for. */
	template <class _CharT>
	concept __char_type = same_as<_CharT, char> \|\| same_as<_CharT, wchar_t>;

	struct _LIBCPP_TEMPLATE_VIS __padding_size_result {
	size_t __before;
	size_t __after;
	};

	_LIBCPP_HIDE_FROM_ABI constexpr __padding_size_result
	__padding_size(size_t __size, size_t __width,
	__format_spec::_Flags::_Alignment __align) {
	_LIBCPP_ASSERT(__width > __size,
	"Don't call this function when no padding is required");
	_LIBCPP_ASSERT(
	__align != __format_spec::_Flags::_Alignment::__default,
	"Caller should adjust the default to the value required by the type");

	size_t __fill = __width - __size;
	switch (__align) {
	case __format_spec::_Flags::_Alignment::__default:
	_LIBCPP_UNREACHABLE();

	case __format_spec::_Flags::_Alignment::__left:
	return {0, __fill};

	case __format_spec::_Flags::_Alignment::__center: {
	// The extra padding is divided per [format.string.std]/3
	// __before = floor(__fill, 2);
	// __after = ceil(__fill, 2);
	size_t __before = __fill / 2;
	size_t __after = __fill - __before;
	return {__before, __after};
	}
	case __format_spec::_Flags::_Alignment::__right:
	return {__fill, 0};
	}
	_LIBCPP_UNREACHABLE();
	}

	/**
	* Writes the input to the output with the required padding.
	*
	* Since the output column width is specified the function can be used for
	* ASCII and Unicode input.
	*
	* @pre [@a __first, @a __last) is a valid range.
	* @pre @a __size <= @a __width. Using this function when this pre-condition
	* doesn't hold incurs an unwanted overhead.
	*
	* @param __out_it The output iterator to write to.
	* @param __first Pointer to the first element to write.
	* @param __last Pointer beyond the last element to write.
	* @param __size The (estimated) output column width. When the elements
	* to be written are ASCII the following condition holds
	* @a __size == @a __last - @a __first.
	* @param __width The number of output columns to write.
	* @param __fill The character used for the alignment of the output.
	* TODO FMT Will probably change to support Unicode grapheme
	* cluster.
	* @param __alignment The requested alignment.
	*
	* @returns An iterator pointing beyond the last element written.
	*
	* @note The type of the elements in range [@a __first, @a __last) can differ
	* from the type of @a __fill. Integer output uses @c std::to_chars for its
	* conversion, which means the [@a __first, @a __last) always contains elements
	* of the type @c char.
	*/
	template <class _CharT, class _Fill>
	_LIBCPP_HIDE_FROM_ABI auto
	__write(output_iterator<const _CharT&> auto __out_it, const _CharT* __first,
	const _CharT* __last, size_t __size, size_t __width, _Fill __fill,
	__format_spec::_Flags::_Alignment __alignment) -> decltype(__out_it) {

	_LIBCPP_ASSERT(__first <= __last, "Not a valid range");
	_LIBCPP_ASSERT(__size < __width, "Precondition failure");

	__padding_size_result __padding =
	__padding_size(__size, __width, __alignment);
	__out_it = _VSTD::fill_n(_VSTD::move(__out_it), __padding.__before, __fill);
	__out_it = _VSTD::copy(__first, __last, _VSTD::move(__out_it));
	return _VSTD::fill_n(_VSTD::move(__out_it), __padding.__after, __fill);
	}

	/**
	* @overload
	*
	* Uses a transformation operation before writing an element.
	*
	* TODO FMT Fill will probably change to support Unicode grapheme cluster.
	*/
	template <class _CharT, class _UnaryOperation, class _Fill>
	_LIBCPP_HIDE_FROM_ABI auto
	__write(output_iterator<const _CharT&> auto __out_it, const _CharT* __first,
	const _CharT* __last, size_t __size, _UnaryOperation __op,
	size_t __width, _Fill __fill,
	__format_spec::_Flags::_Alignment __alignment) -> decltype(__out_it) {

	_LIBCPP_ASSERT(__first <= __last, "Not a valid range");
	_LIBCPP_ASSERT(__size < __width, "Precondition failure");

	__padding_size_result __padding =
	__padding_size(__size, __width, __alignment);
	__out_it = _VSTD::fill_n(_VSTD::move(__out_it), __padding.__before, __fill);
	__out_it = _VSTD::transform(__first, __last, _VSTD::move(__out_it), __op);
	return _VSTD::fill_n(_VSTD::move(__out_it), __padding.__after, __fill);
	}

	/**
	* Writes Unicode input to the output with the required padding.
	*
	* This function does almost the same as the @ref __write function, but handles
	* the width estimation of the Unicode input.
	*
	* @param __str The range [@a __first, @a __last).
	* @param __precision The width to truncate the input string to, use @c -1 for
	* no limit.
	*/
	template <class _CharT, class _Fill>
	_LIBCPP_HIDE_FROM_ABI auto
	__write_unicode(output_iterator<const _CharT&> auto __out_it,
	basic_string_view<_CharT> __str, ptrdiff_t __width,
	ptrdiff_t __precision, _Fill __fill,
	__format_spec::_Flags::_Alignment __alignment)
	-> decltype(__out_it) {

	// This value changes when there Unicode column width limits the output
	// size.
	auto __last = __str.end();
	if (__width != 0 \|\| __precision != -1) {
	__format_spec::__string_alignment<_CharT> __format_traits =
	__format_spec::__get_string_alignment(__str.begin(), __str.end(),
	__width, __precision);

	if (__format_traits.__align)
	return __write(_VSTD::move(__out_it), __str.begin(),
	__format_traits.__last, __format_traits.__size, __width,
	__fill, __alignment);

	// No alignment required update the output based on the precision.
	// This might be the same as __str.end().
	__last = __format_traits.__last;
	}

	// Copy the input to the output. The output size might be limited by the
	// precision.
	return _VSTD::copy(__str.begin(), __last, _VSTD::move(__out_it));
	}

	} // namespace __formatter

	#endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)

	#endif //_LIBCPP_STD_VER > 17

	_LIBCPP_END_NAMESPACE_STD

	_LIBCPP_POP_MACROS

	#endif // _LIBCPP___FORMAT_FORMATTER_H