maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/libcxx/include/__format/formatter_integer.h

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

108 lines
4.3 KiB
C
Raw Normal View History

[libc++][format] Adds integer formatter. Implements the formatter for all fundamental integer types (except `char`, `wchar_t`, and `bool`). [format.formatter.spec]/2.3 For each charT, for each cv-unqualified arithmetic type ArithmeticT other than char, wchar_t, char8_t, char16_t, or char32_t, a specialization ``` template<> struct formatter<ArithmeticT, charT>; ``` This removes the stub implemented in D96664. As an extension it adds partial support for 128-bit integer types. Implements parts of: - P0645 Text Formatting - P1652 Printf corner cases in std::format Completes: - LWG-3248 #b, #B, #o, #x, and #X presentation types misformat negative numbers Reviewed By: #libc, ldionne, vitaut Differential Revision: https://reviews.llvm.org/D103433
2020-12-15 00:39:15 +08:00
// -*- 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_INTEGER_H
#define _LIBCPP___FORMAT_FORMATTER_INTEGER_H
#include <__availability>
[libc++][format] Improve integral formatters. This changes the implementation of the formatter. Instead of inheriting from a specialized parser all formatters will use the same generic parser. This reduces the binary size. The new parser contains some additional fields only used in the chrono formatting. Since this doesn't change the size of the parser the fields are in the generic parser. The parser is designed to fit in 128-bit, making it cheap to pass by value. The new format function is a const member function. This isn't required by the Standard yet, but it will be after LWG-3636 is accepted. Additionally P2286 adds a formattable concept which requires the member function to be const qualified in C++23. This paper is likely to be accepted in the 2022 July plenary. This is based on D125606. That commit did the groundwork and did similar changes for the string formatters. Depends on D125606 Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D128139
2021-12-29 01:48:04 +08:00
#include <__concepts/arithmetic.h>
[libc++][format] Adds integer formatter. Implements the formatter for all fundamental integer types (except `char`, `wchar_t`, and `bool`). [format.formatter.spec]/2.3 For each charT, for each cv-unqualified arithmetic type ArithmeticT other than char, wchar_t, char8_t, char16_t, or char32_t, a specialization ``` template<> struct formatter<ArithmeticT, charT>; ``` This removes the stub implemented in D96664. As an extension it adds partial support for 128-bit integer types. Implements parts of: - P0645 Text Formatting - P1652 Printf corner cases in std::format Completes: - LWG-3248 #b, #B, #o, #x, and #X presentation types misformat negative numbers Reviewed By: #libc, ldionne, vitaut Differential Revision: https://reviews.llvm.org/D103433
2020-12-15 00:39:15 +08:00
#include <__config>
[NFC][libc++][format] Renames __char_type concept. Move the concept to the concepts header and uses a name in the style of P2286. Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D131176
2022-08-04 23:54:20 +08:00
#include <__format/concepts.h>
[libc++][format] Improve integral formatters. This changes the implementation of the formatter. Instead of inheriting from a specialized parser all formatters will use the same generic parser. This reduces the binary size. The new parser contains some additional fields only used in the chrono formatting. Since this doesn't change the size of the parser the fields are in the generic parser. The parser is designed to fit in 128-bit, making it cheap to pass by value. The new format function is a const member function. This isn't required by the Standard yet, but it will be after LWG-3636 is accepted. Additionally P2286 adds a formattable concept which requires the member function to be const qualified in C++23. This paper is likely to be accepted in the 2022 July plenary. This is based on D125606. That commit did the groundwork and did similar changes for the string formatters. Depends on D125606 Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D128139
2021-12-29 01:48:04 +08:00
#include <__format/format_parse_context.h>
[libc++][format] Adds integer formatter. Implements the formatter for all fundamental integer types (except `char`, `wchar_t`, and `bool`). [format.formatter.spec]/2.3 For each charT, for each cv-unqualified arithmetic type ArithmeticT other than char, wchar_t, char8_t, char16_t, or char32_t, a specialization ``` template<> struct formatter<ArithmeticT, charT>; ``` This removes the stub implemented in D96664. As an extension it adds partial support for 128-bit integer types. Implements parts of: - P0645 Text Formatting - P1652 Printf corner cases in std::format Completes: - LWG-3248 #b, #B, #o, #x, and #X presentation types misformat negative numbers Reviewed By: #libc, ldionne, vitaut Differential Revision: https://reviews.llvm.org/D103433
2020-12-15 00:39:15 +08:00
#include <__format/formatter.h>
#include <__format/formatter_integral.h>
[libc++][format] Improve integral formatters. This changes the implementation of the formatter. Instead of inheriting from a specialized parser all formatters will use the same generic parser. This reduces the binary size. The new parser contains some additional fields only used in the chrono formatting. Since this doesn't change the size of the parser the fields are in the generic parser. The parser is designed to fit in 128-bit, making it cheap to pass by value. The new format function is a const member function. This isn't required by the Standard yet, but it will be after LWG-3636 is accepted. Additionally P2286 adds a formattable concept which requires the member function to be const qualified in C++23. This paper is likely to be accepted in the 2022 July plenary. This is based on D125606. That commit did the groundwork and did similar changes for the string formatters. Depends on D125606 Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D128139
2021-12-29 01:48:04 +08:00
#include <__format/formatter_output.h>
[libc++][format] Adds integer formatter. Implements the formatter for all fundamental integer types (except `char`, `wchar_t`, and `bool`). [format.formatter.spec]/2.3 For each charT, for each cv-unqualified arithmetic type ArithmeticT other than char, wchar_t, char8_t, char16_t, or char32_t, a specialization ``` template<> struct formatter<ArithmeticT, charT>; ``` This removes the stub implemented in D96664. As an extension it adds partial support for 128-bit integer types. Implements parts of: - P0645 Text Formatting - P1652 Printf corner cases in std::format Completes: - LWG-3248 #b, #B, #o, #x, and #X presentation types misformat negative numbers Reviewed By: #libc, ldionne, vitaut Differential Revision: https://reviews.llvm.org/D103433
2020-12-15 00:39:15 +08:00
#include <__format/parser_std_format_spec.h>
[libc++] Granularize some more type_traits Reviewed By: ldionne, #libc Spies: libcxx-commits, mgorny Differential Revision: https://reviews.llvm.org/D128948
2022-07-24 22:03:12 +08:00
#include <__type_traits/make_32_64_or_128_bit.h>
[libc++][format] Improve integral formatters. This changes the implementation of the formatter. Instead of inheriting from a specialized parser all formatters will use the same generic parser. This reduces the binary size. The new parser contains some additional fields only used in the chrono formatting. Since this doesn't change the size of the parser the fields are in the generic parser. The parser is designed to fit in 128-bit, making it cheap to pass by value. The new format function is a const member function. This isn't required by the Standard yet, but it will be after LWG-3636 is accepted. Additionally P2286 adds a formattable concept which requires the member function to be const qualified in C++23. This paper is likely to be accepted in the 2022 July plenary. This is based on D125606. That commit did the groundwork and did similar changes for the string formatters. Depends on D125606 Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D128139
2021-12-29 01:48:04 +08:00
#include <type_traits>
[libc++][format] Adds integer formatter. Implements the formatter for all fundamental integer types (except `char`, `wchar_t`, and `bool`). [format.formatter.spec]/2.3 For each charT, for each cv-unqualified arithmetic type ArithmeticT other than char, wchar_t, char8_t, char16_t, or char32_t, a specialization ``` template<> struct formatter<ArithmeticT, charT>; ``` This removes the stub implemented in D96664. As an extension it adds partial support for 128-bit integer types. Implements parts of: - P0645 Text Formatting - P1652 Printf corner cases in std::format Completes: - LWG-3248 #b, #B, #o, #x, and #X presentation types misformat negative numbers Reviewed By: #libc, ldionne, vitaut Differential Revision: https://reviews.llvm.org/D103433
2020-12-15 00:39:15 +08:00
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
[libc++] Normalize all our '#pragma GCC system_header', and regression-test. Now we'll notice if a header forgets to include this magic phrase. Differential Revision: https://reviews.llvm.org/D118800
2022-02-02 09:16:40 +08:00
# pragma GCC system_header
[libc++][format] Adds integer formatter. Implements the formatter for all fundamental integer types (except `char`, `wchar_t`, and `bool`). [format.formatter.spec]/2.3 For each charT, for each cv-unqualified arithmetic type ArithmeticT other than char, wchar_t, char8_t, char16_t, or char32_t, a specialization ``` template<> struct formatter<ArithmeticT, charT>; ``` This removes the stub implemented in D96664. As an extension it adds partial support for 128-bit integer types. Implements parts of: - P0645 Text Formatting - P1652 Printf corner cases in std::format Completes: - LWG-3248 #b, #B, #o, #x, and #X presentation types misformat negative numbers Reviewed By: #libc, ldionne, vitaut Differential Revision: https://reviews.llvm.org/D103433
2020-12-15 00:39:15 +08:00
#endif
[libc++][format] Improve integral formatters. This changes the implementation of the formatter. Instead of inheriting from a specialized parser all formatters will use the same generic parser. This reduces the binary size. The new parser contains some additional fields only used in the chrono formatting. Since this doesn't change the size of the parser the fields are in the generic parser. The parser is designed to fit in 128-bit, making it cheap to pass by value. The new format function is a const member function. This isn't required by the Standard yet, but it will be after LWG-3636 is accepted. Additionally P2286 adds a formattable concept which requires the member function to be const qualified in C++23. This paper is likely to be accepted in the 2022 July plenary. This is based on D125606. That commit did the groundwork and did similar changes for the string formatters. Depends on D125606 Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D128139
2021-12-29 01:48:04 +08:00
_LIBCPP_BEGIN_NAMESPACE_STD
[libc++][format] Adds integer formatter. Implements the formatter for all fundamental integer types (except `char`, `wchar_t`, and `bool`). [format.formatter.spec]/2.3 For each charT, for each cv-unqualified arithmetic type ArithmeticT other than char, wchar_t, char8_t, char16_t, or char32_t, a specialization ``` template<> struct formatter<ArithmeticT, charT>; ``` This removes the stub implemented in D96664. As an extension it adds partial support for 128-bit integer types. Implements parts of: - P0645 Text Formatting - P1652 Printf corner cases in std::format Completes: - LWG-3248 #b, #B, #o, #x, and #X presentation types misformat negative numbers Reviewed By: #libc, ldionne, vitaut Differential Revision: https://reviews.llvm.org/D103433
2020-12-15 00:39:15 +08:00
#if _LIBCPP_STD_VER > 17
[NFC][libc++][format] Renames __char_type concept. Move the concept to the concepts header and uses a name in the style of P2286. Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D131176
2022-08-04 23:54:20 +08:00
template <__fmt_char_type _CharT>
[libc++][format] Improve integral formatters. This changes the implementation of the formatter. Instead of inheriting from a specialized parser all formatters will use the same generic parser. This reduces the binary size. The new parser contains some additional fields only used in the chrono formatting. Since this doesn't change the size of the parser the fields are in the generic parser. The parser is designed to fit in 128-bit, making it cheap to pass by value. The new format function is a const member function. This isn't required by the Standard yet, but it will be after LWG-3636 is accepted. Additionally P2286 adds a formattable concept which requires the member function to be const qualified in C++23. This paper is likely to be accepted in the 2022 July plenary. This is based on D125606. That commit did the groundwork and did similar changes for the string formatters. Depends on D125606 Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D128139
2021-12-29 01:48:04 +08:00
struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT __formatter_integer {
[libc++][format] Adds integer formatter. Implements the formatter for all fundamental integer types (except `char`, `wchar_t`, and `bool`). [format.formatter.spec]/2.3 For each charT, for each cv-unqualified arithmetic type ArithmeticT other than char, wchar_t, char8_t, char16_t, or char32_t, a specialization ``` template<> struct formatter<ArithmeticT, charT>; ``` This removes the stub implemented in D96664. As an extension it adds partial support for 128-bit integer types. Implements parts of: - P0645 Text Formatting - P1652 Printf corner cases in std::format Completes: - LWG-3248 #b, #B, #o, #x, and #X presentation types misformat negative numbers Reviewed By: #libc, ldionne, vitaut Differential Revision: https://reviews.llvm.org/D103433
2020-12-15 00:39:15 +08:00
public:
[libc++][format] Improve integral formatters. This changes the implementation of the formatter. Instead of inheriting from a specialized parser all formatters will use the same generic parser. This reduces the binary size. The new parser contains some additional fields only used in the chrono formatting. Since this doesn't change the size of the parser the fields are in the generic parser. The parser is designed to fit in 128-bit, making it cheap to pass by value. The new format function is a const member function. This isn't required by the Standard yet, but it will be after LWG-3636 is accepted. Additionally P2286 adds a formattable concept which requires the member function to be const qualified in C++23. This paper is likely to be accepted in the 2022 July plenary. This is based on D125606. That commit did the groundwork and did similar changes for the string formatters. Depends on D125606 Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D128139
2021-12-29 01:48:04 +08:00
_LIBCPP_HIDE_FROM_ABI constexpr auto
parse(basic_format_parse_context<_CharT>& __parse_ctx) -> decltype(__parse_ctx.begin()) {
auto __result = __parser_.__parse(__parse_ctx, __format_spec::__fields_integral);
__format_spec::__process_parsed_integer(__parser_);
return __result;
[libc++][format] Adds integer formatter. Implements the formatter for all fundamental integer types (except `char`, `wchar_t`, and `bool`). [format.formatter.spec]/2.3 For each charT, for each cv-unqualified arithmetic type ArithmeticT other than char, wchar_t, char8_t, char16_t, or char32_t, a specialization ``` template<> struct formatter<ArithmeticT, charT>; ``` This removes the stub implemented in D96664. As an extension it adds partial support for 128-bit integer types. Implements parts of: - P0645 Text Formatting - P1652 Printf corner cases in std::format Completes: - LWG-3248 #b, #B, #o, #x, and #X presentation types misformat negative numbers Reviewed By: #libc, ldionne, vitaut Differential Revision: https://reviews.llvm.org/D103433
2020-12-15 00:39:15 +08:00
}
[libc++][format] Improve integral formatters. This changes the implementation of the formatter. Instead of inheriting from a specialized parser all formatters will use the same generic parser. This reduces the binary size. The new parser contains some additional fields only used in the chrono formatting. Since this doesn't change the size of the parser the fields are in the generic parser. The parser is designed to fit in 128-bit, making it cheap to pass by value. The new format function is a const member function. This isn't required by the Standard yet, but it will be after LWG-3636 is accepted. Additionally P2286 adds a formattable concept which requires the member function to be const qualified in C++23. This paper is likely to be accepted in the 2022 July plenary. This is based on D125606. That commit did the groundwork and did similar changes for the string formatters. Depends on D125606 Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D128139
2021-12-29 01:48:04 +08:00
template <integral _Tp>
_LIBCPP_HIDE_FROM_ABI auto format(_Tp __value, auto& __ctx) const -> decltype(__ctx.out()) {
__format_spec::__parsed_specifications<_CharT> __specs = __parser_.__get_parsed_std_specifications(__ctx);
if (__specs.__std_.__type_ == __format_spec::__type::__char)
return __formatter::__format_char(__value, __ctx.out(), __specs);
[libc++][format] Adds integer formatter. Implements the formatter for all fundamental integer types (except `char`, `wchar_t`, and `bool`). [format.formatter.spec]/2.3 For each charT, for each cv-unqualified arithmetic type ArithmeticT other than char, wchar_t, char8_t, char16_t, or char32_t, a specialization ``` template<> struct formatter<ArithmeticT, charT>; ``` This removes the stub implemented in D96664. As an extension it adds partial support for 128-bit integer types. Implements parts of: - P0645 Text Formatting - P1652 Printf corner cases in std::format Completes: - LWG-3248 #b, #B, #o, #x, and #X presentation types misformat negative numbers Reviewed By: #libc, ldionne, vitaut Differential Revision: https://reviews.llvm.org/D103433
2020-12-15 00:39:15 +08:00
[libc++][format] Improve integral formatters. This changes the implementation of the formatter. Instead of inheriting from a specialized parser all formatters will use the same generic parser. This reduces the binary size. The new parser contains some additional fields only used in the chrono formatting. Since this doesn't change the size of the parser the fields are in the generic parser. The parser is designed to fit in 128-bit, making it cheap to pass by value. The new format function is a const member function. This isn't required by the Standard yet, but it will be after LWG-3636 is accepted. Additionally P2286 adds a formattable concept which requires the member function to be const qualified in C++23. This paper is likely to be accepted in the 2022 July plenary. This is based on D125606. That commit did the groundwork and did similar changes for the string formatters. Depends on D125606 Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D128139
2021-12-29 01:48:04 +08:00
using _Type = __make_32_64_or_128_bit_t<_Tp>;
static_assert(!is_same<_Type, void>::value, "unsupported integral type used in __formatter_integer::__format");
// Reduce the number of instantiation of the integer formatter
return __formatter::__format_integer(static_cast<_Type>(__value), __ctx, __specs);
}
[libc++][format] Adds integer formatter. Implements the formatter for all fundamental integer types (except `char`, `wchar_t`, and `bool`). [format.formatter.spec]/2.3 For each charT, for each cv-unqualified arithmetic type ArithmeticT other than char, wchar_t, char8_t, char16_t, or char32_t, a specialization ``` template<> struct formatter<ArithmeticT, charT>; ``` This removes the stub implemented in D96664. As an extension it adds partial support for 128-bit integer types. Implements parts of: - P0645 Text Formatting - P1652 Printf corner cases in std::format Completes: - LWG-3248 #b, #B, #o, #x, and #X presentation types misformat negative numbers Reviewed By: #libc, ldionne, vitaut Differential Revision: https://reviews.llvm.org/D103433
2020-12-15 00:39:15 +08:00
[libc++][format] Improve integral formatters. This changes the implementation of the formatter. Instead of inheriting from a specialized parser all formatters will use the same generic parser. This reduces the binary size. The new parser contains some additional fields only used in the chrono formatting. Since this doesn't change the size of the parser the fields are in the generic parser. The parser is designed to fit in 128-bit, making it cheap to pass by value. The new format function is a const member function. This isn't required by the Standard yet, but it will be after LWG-3636 is accepted. Additionally P2286 adds a formattable concept which requires the member function to be const qualified in C++23. This paper is likely to be accepted in the 2022 July plenary. This is based on D125606. That commit did the groundwork and did similar changes for the string formatters. Depends on D125606 Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D128139
2021-12-29 01:48:04 +08:00
__format_spec::__parser<_CharT> __parser_;
};
[libc++][format] Adds integer formatter. Implements the formatter for all fundamental integer types (except `char`, `wchar_t`, and `bool`). [format.formatter.spec]/2.3 For each charT, for each cv-unqualified arithmetic type ArithmeticT other than char, wchar_t, char8_t, char16_t, or char32_t, a specialization ``` template<> struct formatter<ArithmeticT, charT>; ``` This removes the stub implemented in D96664. As an extension it adds partial support for 128-bit integer types. Implements parts of: - P0645 Text Formatting - P1652 Printf corner cases in std::format Completes: - LWG-3248 #b, #B, #o, #x, and #X presentation types misformat negative numbers Reviewed By: #libc, ldionne, vitaut Differential Revision: https://reviews.llvm.org/D103433
2020-12-15 00:39:15 +08:00
// Signed integral types.
[NFC][libc++][format] Renames __char_type concept. Move the concept to the concepts header and uses a name in the style of P2286. Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D131176
2022-08-04 23:54:20 +08:00
template <__fmt_char_type _CharT>
[libc++][format] Improve integral formatters. This changes the implementation of the formatter. Instead of inheriting from a specialized parser all formatters will use the same generic parser. This reduces the binary size. The new parser contains some additional fields only used in the chrono formatting. Since this doesn't change the size of the parser the fields are in the generic parser. The parser is designed to fit in 128-bit, making it cheap to pass by value. The new format function is a const member function. This isn't required by the Standard yet, but it will be after LWG-3636 is accepted. Additionally P2286 adds a formattable concept which requires the member function to be const qualified in C++23. This paper is likely to be accepted in the 2022 July plenary. This is based on D125606. That commit did the groundwork and did similar changes for the string formatters. Depends on D125606 Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D128139
2021-12-29 01:48:04 +08:00
struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<signed char, _CharT>
: public __formatter_integer<_CharT> {};
[NFC][libc++][format] Renames __char_type concept. Move the concept to the concepts header and uses a name in the style of P2286. Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D131176
2022-08-04 23:54:20 +08:00
template <__fmt_char_type _CharT>
[libc++][format] Improve integral formatters. This changes the implementation of the formatter. Instead of inheriting from a specialized parser all formatters will use the same generic parser. This reduces the binary size. The new parser contains some additional fields only used in the chrono formatting. Since this doesn't change the size of the parser the fields are in the generic parser. The parser is designed to fit in 128-bit, making it cheap to pass by value. The new format function is a const member function. This isn't required by the Standard yet, but it will be after LWG-3636 is accepted. Additionally P2286 adds a formattable concept which requires the member function to be const qualified in C++23. This paper is likely to be accepted in the 2022 July plenary. This is based on D125606. That commit did the groundwork and did similar changes for the string formatters. Depends on D125606 Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D128139
2021-12-29 01:48:04 +08:00
struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<short, _CharT> : public __formatter_integer<_CharT> {
};
[NFC][libc++][format] Renames __char_type concept. Move the concept to the concepts header and uses a name in the style of P2286. Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D131176
2022-08-04 23:54:20 +08:00
template <__fmt_char_type _CharT>
[libc++][format] Improve integral formatters. This changes the implementation of the formatter. Instead of inheriting from a specialized parser all formatters will use the same generic parser. This reduces the binary size. The new parser contains some additional fields only used in the chrono formatting. Since this doesn't change the size of the parser the fields are in the generic parser. The parser is designed to fit in 128-bit, making it cheap to pass by value. The new format function is a const member function. This isn't required by the Standard yet, but it will be after LWG-3636 is accepted. Additionally P2286 adds a formattable concept which requires the member function to be const qualified in C++23. This paper is likely to be accepted in the 2022 July plenary. This is based on D125606. That commit did the groundwork and did similar changes for the string formatters. Depends on D125606 Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D128139
2021-12-29 01:48:04 +08:00
struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<int, _CharT> : public __formatter_integer<_CharT> {};
[NFC][libc++][format] Renames __char_type concept. Move the concept to the concepts header and uses a name in the style of P2286. Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D131176
2022-08-04 23:54:20 +08:00
template <__fmt_char_type _CharT>
[libc++][format] Improve integral formatters. This changes the implementation of the formatter. Instead of inheriting from a specialized parser all formatters will use the same generic parser. This reduces the binary size. The new parser contains some additional fields only used in the chrono formatting. Since this doesn't change the size of the parser the fields are in the generic parser. The parser is designed to fit in 128-bit, making it cheap to pass by value. The new format function is a const member function. This isn't required by the Standard yet, but it will be after LWG-3636 is accepted. Additionally P2286 adds a formattable concept which requires the member function to be const qualified in C++23. This paper is likely to be accepted in the 2022 July plenary. This is based on D125606. That commit did the groundwork and did similar changes for the string formatters. Depends on D125606 Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D128139
2021-12-29 01:48:04 +08:00
struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<long, _CharT> : public __formatter_integer<_CharT> {};
[NFC][libc++][format] Renames __char_type concept. Move the concept to the concepts header and uses a name in the style of P2286. Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D131176
2022-08-04 23:54:20 +08:00
template <__fmt_char_type _CharT>
[libc++][format] Improve integral formatters. This changes the implementation of the formatter. Instead of inheriting from a specialized parser all formatters will use the same generic parser. This reduces the binary size. The new parser contains some additional fields only used in the chrono formatting. Since this doesn't change the size of the parser the fields are in the generic parser. The parser is designed to fit in 128-bit, making it cheap to pass by value. The new format function is a const member function. This isn't required by the Standard yet, but it will be after LWG-3636 is accepted. Additionally P2286 adds a formattable concept which requires the member function to be const qualified in C++23. This paper is likely to be accepted in the 2022 July plenary. This is based on D125606. That commit did the groundwork and did similar changes for the string formatters. Depends on D125606 Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D128139
2021-12-29 01:48:04 +08:00
struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<long long, _CharT>
: public __formatter_integer<_CharT> {};
# ifndef _LIBCPP_HAS_NO_INT128
[NFC][libc++][format] Renames __char_type concept. Move the concept to the concepts header and uses a name in the style of P2286. Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D131176
2022-08-04 23:54:20 +08:00
template <__fmt_char_type _CharT>
[libc++][format] Improve integral formatters. This changes the implementation of the formatter. Instead of inheriting from a specialized parser all formatters will use the same generic parser. This reduces the binary size. The new parser contains some additional fields only used in the chrono formatting. Since this doesn't change the size of the parser the fields are in the generic parser. The parser is designed to fit in 128-bit, making it cheap to pass by value. The new format function is a const member function. This isn't required by the Standard yet, but it will be after LWG-3636 is accepted. Additionally P2286 adds a formattable concept which requires the member function to be const qualified in C++23. This paper is likely to be accepted in the 2022 July plenary. This is based on D125606. That commit did the groundwork and did similar changes for the string formatters. Depends on D125606 Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D128139
2021-12-29 01:48:04 +08:00
struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<__int128_t, _CharT>
[libc++][format] Implements 128-bit support. With to_chars supporting 128-bit it's possible to support the full 128-bit range in format. This only removes the previous restrictions and updates the tests to validate proper support. Depends on D128929. Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D129007
2022-07-02 01:35:38 +08:00
: public __formatter_integer<_CharT> {};
[libc++][format] Improve integral formatters. This changes the implementation of the formatter. Instead of inheriting from a specialized parser all formatters will use the same generic parser. This reduces the binary size. The new parser contains some additional fields only used in the chrono formatting. Since this doesn't change the size of the parser the fields are in the generic parser. The parser is designed to fit in 128-bit, making it cheap to pass by value. The new format function is a const member function. This isn't required by the Standard yet, but it will be after LWG-3636 is accepted. Additionally P2286 adds a formattable concept which requires the member function to be const qualified in C++23. This paper is likely to be accepted in the 2022 July plenary. This is based on D125606. That commit did the groundwork and did similar changes for the string formatters. Depends on D125606 Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D128139
2021-12-29 01:48:04 +08:00
# endif
[libc++][format] Adds integer formatter. Implements the formatter for all fundamental integer types (except `char`, `wchar_t`, and `bool`). [format.formatter.spec]/2.3 For each charT, for each cv-unqualified arithmetic type ArithmeticT other than char, wchar_t, char8_t, char16_t, or char32_t, a specialization ``` template<> struct formatter<ArithmeticT, charT>; ``` This removes the stub implemented in D96664. As an extension it adds partial support for 128-bit integer types. Implements parts of: - P0645 Text Formatting - P1652 Printf corner cases in std::format Completes: - LWG-3248 #b, #B, #o, #x, and #X presentation types misformat negative numbers Reviewed By: #libc, ldionne, vitaut Differential Revision: https://reviews.llvm.org/D103433
2020-12-15 00:39:15 +08:00
// Unsigned integral types.
[NFC][libc++][format] Renames __char_type concept. Move the concept to the concepts header and uses a name in the style of P2286. Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D131176
2022-08-04 23:54:20 +08:00
template <__fmt_char_type _CharT>
[libc++][format] Improve integral formatters. This changes the implementation of the formatter. Instead of inheriting from a specialized parser all formatters will use the same generic parser. This reduces the binary size. The new parser contains some additional fields only used in the chrono formatting. Since this doesn't change the size of the parser the fields are in the generic parser. The parser is designed to fit in 128-bit, making it cheap to pass by value. The new format function is a const member function. This isn't required by the Standard yet, but it will be after LWG-3636 is accepted. Additionally P2286 adds a formattable concept which requires the member function to be const qualified in C++23. This paper is likely to be accepted in the 2022 July plenary. This is based on D125606. That commit did the groundwork and did similar changes for the string formatters. Depends on D125606 Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D128139
2021-12-29 01:48:04 +08:00
struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<unsigned char, _CharT>
: public __formatter_integer<_CharT> {};
[NFC][libc++][format] Renames __char_type concept. Move the concept to the concepts header and uses a name in the style of P2286. Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D131176
2022-08-04 23:54:20 +08:00
template <__fmt_char_type _CharT>
[libc++][format] Improve integral formatters. This changes the implementation of the formatter. Instead of inheriting from a specialized parser all formatters will use the same generic parser. This reduces the binary size. The new parser contains some additional fields only used in the chrono formatting. Since this doesn't change the size of the parser the fields are in the generic parser. The parser is designed to fit in 128-bit, making it cheap to pass by value. The new format function is a const member function. This isn't required by the Standard yet, but it will be after LWG-3636 is accepted. Additionally P2286 adds a formattable concept which requires the member function to be const qualified in C++23. This paper is likely to be accepted in the 2022 July plenary. This is based on D125606. That commit did the groundwork and did similar changes for the string formatters. Depends on D125606 Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D128139
2021-12-29 01:48:04 +08:00
struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<unsigned short, _CharT>
: public __formatter_integer<_CharT> {};
[NFC][libc++][format] Renames __char_type concept. Move the concept to the concepts header and uses a name in the style of P2286. Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D131176
2022-08-04 23:54:20 +08:00
template <__fmt_char_type _CharT>
[libc++][format] Improve integral formatters. This changes the implementation of the formatter. Instead of inheriting from a specialized parser all formatters will use the same generic parser. This reduces the binary size. The new parser contains some additional fields only used in the chrono formatting. Since this doesn't change the size of the parser the fields are in the generic parser. The parser is designed to fit in 128-bit, making it cheap to pass by value. The new format function is a const member function. This isn't required by the Standard yet, but it will be after LWG-3636 is accepted. Additionally P2286 adds a formattable concept which requires the member function to be const qualified in C++23. This paper is likely to be accepted in the 2022 July plenary. This is based on D125606. That commit did the groundwork and did similar changes for the string formatters. Depends on D125606 Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D128139
2021-12-29 01:48:04 +08:00
struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<unsigned, _CharT>
: public __formatter_integer<_CharT> {};
[NFC][libc++][format] Renames __char_type concept. Move the concept to the concepts header and uses a name in the style of P2286. Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D131176
2022-08-04 23:54:20 +08:00
template <__fmt_char_type _CharT>
[libc++][format] Improve integral formatters. This changes the implementation of the formatter. Instead of inheriting from a specialized parser all formatters will use the same generic parser. This reduces the binary size. The new parser contains some additional fields only used in the chrono formatting. Since this doesn't change the size of the parser the fields are in the generic parser. The parser is designed to fit in 128-bit, making it cheap to pass by value. The new format function is a const member function. This isn't required by the Standard yet, but it will be after LWG-3636 is accepted. Additionally P2286 adds a formattable concept which requires the member function to be const qualified in C++23. This paper is likely to be accepted in the 2022 July plenary. This is based on D125606. That commit did the groundwork and did similar changes for the string formatters. Depends on D125606 Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D128139
2021-12-29 01:48:04 +08:00
struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<unsigned long, _CharT>
: public __formatter_integer<_CharT> {};
[NFC][libc++][format] Renames __char_type concept. Move the concept to the concepts header and uses a name in the style of P2286. Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D131176
2022-08-04 23:54:20 +08:00
template <__fmt_char_type _CharT>
[libc++][format] Improve integral formatters. This changes the implementation of the formatter. Instead of inheriting from a specialized parser all formatters will use the same generic parser. This reduces the binary size. The new parser contains some additional fields only used in the chrono formatting. Since this doesn't change the size of the parser the fields are in the generic parser. The parser is designed to fit in 128-bit, making it cheap to pass by value. The new format function is a const member function. This isn't required by the Standard yet, but it will be after LWG-3636 is accepted. Additionally P2286 adds a formattable concept which requires the member function to be const qualified in C++23. This paper is likely to be accepted in the 2022 July plenary. This is based on D125606. That commit did the groundwork and did similar changes for the string formatters. Depends on D125606 Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D128139
2021-12-29 01:48:04 +08:00
struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<unsigned long long, _CharT>
: public __formatter_integer<_CharT> {};
# ifndef _LIBCPP_HAS_NO_INT128
[NFC][libc++][format] Renames __char_type concept. Move the concept to the concepts header and uses a name in the style of P2286. Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D131176
2022-08-04 23:54:20 +08:00
template <__fmt_char_type _CharT>
[libc++][format] Improve integral formatters. This changes the implementation of the formatter. Instead of inheriting from a specialized parser all formatters will use the same generic parser. This reduces the binary size. The new parser contains some additional fields only used in the chrono formatting. Since this doesn't change the size of the parser the fields are in the generic parser. The parser is designed to fit in 128-bit, making it cheap to pass by value. The new format function is a const member function. This isn't required by the Standard yet, but it will be after LWG-3636 is accepted. Additionally P2286 adds a formattable concept which requires the member function to be const qualified in C++23. This paper is likely to be accepted in the 2022 July plenary. This is based on D125606. That commit did the groundwork and did similar changes for the string formatters. Depends on D125606 Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D128139
2021-12-29 01:48:04 +08:00
struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<__uint128_t, _CharT>
[libc++][format] Implements 128-bit support. With to_chars supporting 128-bit it's possible to support the full 128-bit range in format. This only removes the previous restrictions and updates the tests to validate proper support. Depends on D128929. Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D129007
2022-07-02 01:35:38 +08:00
: public __formatter_integer<_CharT> {};
[libc++][format] Improve integral formatters. This changes the implementation of the formatter. Instead of inheriting from a specialized parser all formatters will use the same generic parser. This reduces the binary size. The new parser contains some additional fields only used in the chrono formatting. Since this doesn't change the size of the parser the fields are in the generic parser. The parser is designed to fit in 128-bit, making it cheap to pass by value. The new format function is a const member function. This isn't required by the Standard yet, but it will be after LWG-3636 is accepted. Additionally P2286 adds a formattable concept which requires the member function to be const qualified in C++23. This paper is likely to be accepted in the 2022 July plenary. This is based on D125606. That commit did the groundwork and did similar changes for the string formatters. Depends on D125606 Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D128139
2021-12-29 01:48:04 +08:00
# endif
[libc++][format] Adds integer formatter. Implements the formatter for all fundamental integer types (except `char`, `wchar_t`, and `bool`). [format.formatter.spec]/2.3 For each charT, for each cv-unqualified arithmetic type ArithmeticT other than char, wchar_t, char8_t, char16_t, or char32_t, a specialization ``` template<> struct formatter<ArithmeticT, charT>; ``` This removes the stub implemented in D96664. As an extension it adds partial support for 128-bit integer types. Implements parts of: - P0645 Text Formatting - P1652 Printf corner cases in std::format Completes: - LWG-3248 #b, #B, #o, #x, and #X presentation types misformat negative numbers Reviewed By: #libc, ldionne, vitaut Differential Revision: https://reviews.llvm.org/D103433
2020-12-15 00:39:15 +08:00
#endif //_LIBCPP_STD_VER > 17
_LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___FORMAT_FORMATTER_INTEGER_H