813 lines
32 KiB
C
813 lines
32 KiB
C
|
//
|
||
|
|
// Copyright 2018 The Abseil Authors.
|
||
|
|
//
|
||
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
||
|
|
// you may not use this file except in compliance with the License.
|
||
|
|
// You may obtain a copy of the License at
|
||
|
|
//
|
||
|
|
// https://www.apache.org/licenses/LICENSE-2.0
|
||
|
|
//
|
||
|
|
// Unless required by applicable law or agreed to in writing, software
|
||
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
||
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||
|
|
// See the License for the specific language governing permissions and
|
||
|
|
// limitations under the License.
|
||
|
|
//
|
||
|
|
// -----------------------------------------------------------------------------
|
||
|
|
// File: str_format.h
|
||
|
|
// -----------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
// The `str_format` library is a typesafe replacement for the family of
|
||
|
|
// `printf()` string formatting routines within the `<cstdio>` standard library
|
||
|
|
// header. Like the `printf` family, `str_format` uses a "format string" to
|
||
|
|
// perform argument substitutions based on types. See the `FormatSpec` section
|
||
|
|
// below for format string documentation.
|
||
|
|
//
|
||
|
|
// Example:
|
||
|
|
//
|
||
|
|
// std::string s = absl::StrFormat(
|
||
|
|
// "%s %s You have $%d!", "Hello", name, dollars);
|
||
|
|
//
|
||
|
|
// The library consists of the following basic utilities:
|
||
|
|
//
|
||
|
|
// * `absl::StrFormat()`, a type-safe replacement for `std::sprintf()`, to
|
||
|
|
// write a format string to a `string` value.
|
||
|
|
// * `absl::StrAppendFormat()` to append a format string to a `string`
|
||
|
|
// * `absl::StreamFormat()` to more efficiently write a format string to a
|
||
|
|
// stream, such as`std::cout`.
|
||
|
|
// * `absl::PrintF()`, `absl::FPrintF()` and `absl::SNPrintF()` as
|
||
|
|
// replacements for `std::printf()`, `std::fprintf()` and `std::snprintf()`.
|
||
|
|
//
|
||
|
|
// Note: a version of `std::sprintf()` is not supported as it is
|
||
|
|
// generally unsafe due to buffer overflows.
|
||
|
|
//
|
||
|
|
// Additionally, you can provide a format string (and its associated arguments)
|
||
|
|
// using one of the following abstractions:
|
||
|
|
//
|
||
|
|
// * A `FormatSpec` class template fully encapsulates a format string and its
|
||
|
|
// type arguments and is usually provided to `str_format` functions as a
|
||
|
|
// variadic argument of type `FormatSpec<Arg...>`. The `FormatSpec<Args...>`
|
||
|
|
// template is evaluated at compile-time, providing type safety.
|
||
|
|
// * A `ParsedFormat` instance, which encapsulates a specific, pre-compiled
|
||
|
|
// format string for a specific set of type(s), and which can be passed
|
||
|
|
// between API boundaries. (The `FormatSpec` type should not be used
|
||
|
|
// directly except as an argument type for wrapper functions.)
|
||
|
|
//
|
||
|
|
// The `str_format` library provides the ability to output its format strings to
|
||
|
|
// arbitrary sink types:
|
||
|
|
//
|
||
|
|
// * A generic `Format()` function to write outputs to arbitrary sink types,
|
||
|
|
// which must implement a `FormatRawSink` interface.
|
||
|
|
//
|
||
|
|
// * A `FormatUntyped()` function that is similar to `Format()` except it is
|
||
|
|
// loosely typed. `FormatUntyped()` is not a template and does not perform
|
||
|
|
// any compile-time checking of the format string; instead, it returns a
|
||
|
|
// boolean from a runtime check.
|
||
|
|
//
|
||
|
|
// In addition, the `str_format` library provides extension points for
|
||
|
|
// augmenting formatting to new types. See "StrFormat Extensions" below.
|
||
|
|
|
||
|
|
#ifndef ABSL_STRINGS_STR_FORMAT_H_
|
||
|
|
#define ABSL_STRINGS_STR_FORMAT_H_
|
||
|
|
|
||
|
|
#include <cstdio>
|
||
|
|
#include <string>
|
||
|
|
|
||
|
|
#include "absl/strings/internal/str_format/arg.h" // IWYU pragma: export
|
||
|
|
#include "absl/strings/internal/str_format/bind.h" // IWYU pragma: export
|
||
|
|
#include "absl/strings/internal/str_format/checker.h" // IWYU pragma: export
|
||
|
|
#include "absl/strings/internal/str_format/extension.h" // IWYU pragma: export
|
||
|
|
#include "absl/strings/internal/str_format/parser.h" // IWYU pragma: export
|
||
|
|
|
||
|
|
namespace absl {
|
||
|
|
ABSL_NAMESPACE_BEGIN
|
||
|
|
|
||
|
|
// UntypedFormatSpec
|
||
|
|
//
|
||
|
|
// A type-erased class that can be used directly within untyped API entry
|
||
|
|
// points. An `UntypedFormatSpec` is specifically used as an argument to
|
||
|
|
// `FormatUntyped()`.
|
||
|
|
//
|
||
|
|
// Example:
|
||
|
|
//
|
||
|
|
// absl::UntypedFormatSpec format("%d");
|
||
|
|
// std::string out;
|
||
|
|
// CHECK(absl::FormatUntyped(&out, format, {absl::FormatArg(1)}));
|
||
|
|
class UntypedFormatSpec {
|
||
|
|
public:
|
||
|
|
UntypedFormatSpec() = delete;
|
||
|
|
UntypedFormatSpec(const UntypedFormatSpec&) = delete;
|
||
|
|
UntypedFormatSpec& operator=(const UntypedFormatSpec&) = delete;
|
||
|
|
|
||
|
|
explicit UntypedFormatSpec(string_view s) : spec_(s) {}
|
||
|
|
|
||
|
|
protected:
|
||
|
|
explicit UntypedFormatSpec(const str_format_internal::ParsedFormatBase* pc)
|
||
|
|
: spec_(pc) {}
|
||
|
|
|
||
|
|
private:
|
||
|
|
friend str_format_internal::UntypedFormatSpecImpl;
|
||
|
|
str_format_internal::UntypedFormatSpecImpl spec_;
|
||
|
|
};
|
||
|
|
|
||
|
|
// FormatStreamed()
|
||
|
|
//
|
||
|
|
// Takes a streamable argument and returns an object that can print it
|
||
|
|
// with '%s'. Allows printing of types that have an `operator<<` but no
|
||
|
|
// intrinsic type support within `StrFormat()` itself.
|
||
|
|
//
|
||
|
|
// Example:
|
||
|
|
//
|
||
|
|
// absl::StrFormat("%s", absl::FormatStreamed(obj));
|
||
|
|
template <typename T>
|
||
|
|
str_format_internal::StreamedWrapper<T> FormatStreamed(const T& v) {
|
||
|
|
return str_format_internal::StreamedWrapper<T>(v);
|
||
|
|
}
|
||
|
|
|
||
|
|
// FormatCountCapture
|
||
|
|
//
|
||
|
|
// This class provides a way to safely wrap `StrFormat()` captures of `%n`
|
||
|
|
// conversions, which denote the number of characters written by a formatting
|
||
|
|
// operation to this point, into an integer value.
|
||
|
|
//
|
||
|
|
// This wrapper is designed to allow safe usage of `%n` within `StrFormat(); in
|
||
|
|
// the `printf()` family of functions, `%n` is not safe to use, as the `int *`
|
||
|
|
// buffer can be used to capture arbitrary data.
|
||
|
|
//
|
||
|
|
// Example:
|
||
|
|
//
|
||
|
|
// int n = 0;
|
||
|
|
// std::string s = absl::StrFormat("%s%d%n", "hello", 123,
|
||
|
|
// absl::FormatCountCapture(&n));
|
||
|
|
// EXPECT_EQ(8, n);
|
||
|
|
class FormatCountCapture {
|
||
|
|
public:
|
||
|
|
explicit FormatCountCapture(int* p) : p_(p) {}
|
||
|
|
|
||
|
|
private:
|
||
|
|
// FormatCountCaptureHelper is used to define FormatConvertImpl() for this
|
||
|
|
// class.
|
||
|
|
friend struct str_format_internal::FormatCountCaptureHelper;
|
||
|
|
// Unused() is here because of the false positive from -Wunused-private-field
|
||
|
|
// p_ is used in the templated function of the friend FormatCountCaptureHelper
|
||
|
|
// class.
|
||
|
|
int* Unused() { return p_; }
|
||
|
|
int* p_;
|
||
|
|
};
|
||
|
|
|
||
|
|
// FormatSpec
|
||
|
|
//
|
||
|
|
// The `FormatSpec` type defines the makeup of a format string within the
|
||
|
|
// `str_format` library. It is a variadic class template that is evaluated at
|
||
|
|
// compile-time, according to the format string and arguments that are passed to
|
||
|
|
// it.
|
||
|
|
//
|
||
|
|
// You should not need to manipulate this type directly. You should only name it
|
||
|
|
// if you are writing wrapper functions which accept format arguments that will
|
||
|
|
// be provided unmodified to functions in this library. Such a wrapper function
|
||
|
|
// might be a class method that provides format arguments and/or internally uses
|
||
|
|
// the result of formatting.
|
||
|
|
//
|
||
|
|
// For a `FormatSpec` to be valid at compile-time, it must be provided as
|
||
|
|
// either:
|
||
|
|
//
|
||
|
|
// * A `constexpr` literal or `absl::string_view`, which is how it most often
|
||
|
|
// used.
|
||
|
|
// * A `ParsedFormat` instantiation, which ensures the format string is
|
||
|
|
// valid before use. (See below.)
|
||
|
|
//
|
||
|
|
// Example:
|
||
|
|
//
|
||
|
|
// // Provided as a string literal.
|
||
|
|
// absl::StrFormat("Welcome to %s, Number %d!", "The Village", 6);
|
||
|
|
//
|
||
|
|
// // Provided as a constexpr absl::string_view.
|
||
|
|
// constexpr absl::string_view formatString = "Welcome to %s, Number %d!";
|
||
|
|
// absl::StrFormat(formatString, "The Village", 6);
|
||
|
|
//
|
||
|
|
// // Provided as a pre-compiled ParsedFormat object.
|
||
|
|
// // Note that this example is useful only for illustration purposes.
|
||
|
|
// absl::ParsedFormat<'s', 'd'> formatString("Welcome to %s, Number %d!");
|
||
|
|
// absl::StrFormat(formatString, "TheVillage", 6);
|
||
|
|
//
|
||
|
|
// A format string generally follows the POSIX syntax as used within the POSIX
|
||
|
|
// `printf` specification.
|
||
|
|
//
|
||
|
|
// (See http://pubs.opengroup.org/onlinepubs/9699919799/functions/fprintf.html.)
|
||
|
|
//
|
||
|
|
// In specific, the `FormatSpec` supports the following type specifiers:
|
||
|
|
// * `c` for characters
|
||
|
|
// * `s` for strings
|
||
|
|
// * `d` or `i` for integers
|
||
|
|
// * `o` for unsigned integer conversions into octal
|
||
|
|
// * `x` or `X` for unsigned integer conversions into hex
|
||
|
|
// * `u` for unsigned integers
|
||
|
|
// * `f` or `F` for floating point values into decimal notation
|
||
|
|
// * `e` or `E` for floating point values into exponential notation
|
||
|
|
// * `a` or `A` for floating point values into hex exponential notation
|
||
|
|
// * `g` or `G` for floating point values into decimal or exponential
|
||
|
|
// notation based on their precision
|
||
|
|
// * `p` for pointer address values
|
||
|
|
// * `n` for the special case of writing out the number of characters
|
||
|
|
// written to this point. The resulting value must be captured within an
|
||
|
|
// `absl::FormatCountCapture` type.
|
||
|
|
//
|
||
|
|
// Implementation-defined behavior:
|
||
|
|
// * A null pointer provided to "%s" or "%p" is output as "(nil)".
|
||
|
|
// * A non-null pointer provided to "%p" is output in hex as if by %#x or
|
||
|
|
// %#lx.
|
||
|
|
//
|
||
|
|
// NOTE: `o`, `x\X` and `u` will convert signed values to their unsigned
|
||
|
|
// counterpart before formatting.
|
||
|
|
//
|
||
|
|
// Examples:
|
||
|
|
// "%c", 'a' -> "a"
|
||
|
|
// "%c", 32 -> " "
|
||
|
|
// "%s", "C" -> "C"
|
||
|
|
// "%s", std::string("C++") -> "C++"
|
||
|
|
// "%d", -10 -> "-10"
|
||
|
|
// "%o", 10 -> "12"
|
||
|
|
// "%x", 16 -> "10"
|
||
|
|
// "%f", 123456789 -> "123456789.000000"
|
||
|
|
// "%e", .01 -> "1.00000e-2"
|
||
|
|
// "%a", -3.0 -> "-0x1.8p+1"
|
||
|
|
// "%g", .01 -> "1e-2"
|
||
|
|
// "%p", (void*)&value -> "0x7ffdeb6ad2a4"
|
||
|
|
//
|
||
|
|
// int n = 0;
|
||
|
|
// std::string s = absl::StrFormat(
|
||
|
|
// "%s%d%n", "hello", 123, absl::FormatCountCapture(&n));
|
||
|
|
// EXPECT_EQ(8, n);
|
||
|
|
//
|
||
|
|
// The `FormatSpec` intrinsically supports all of these fundamental C++ types:
|
||
|
|
//
|
||
|
|
// * Characters: `char`, `signed char`, `unsigned char`
|
||
|
|
// * Integers: `int`, `short`, `unsigned short`, `unsigned`, `long`,
|
||
|
|
// `unsigned long`, `long long`, `unsigned long long`
|
||
|
|
// * Floating-point: `float`, `double`, `long double`
|
||
|
|
//
|
||
|
|
// However, in the `str_format` library, a format conversion specifies a broader
|
||
|
|
// C++ conceptual category instead of an exact type. For example, `%s` binds to
|
||
|
|
// any string-like argument, so `std::string`, `absl::string_view`, and
|
||
|
|
// `const char*` are all accepted. Likewise, `%d` accepts any integer-like
|
||
|
|
// argument, etc.
|
||
|
|
|
||
|
|
template <typename... Args>
|
||
|
|
using FormatSpec = str_format_internal::FormatSpecTemplate<
|
||
|
|
str_format_internal::ArgumentToConv<Args>()...>;
|
||
|
|
|
||
|
|
// ParsedFormat
|
||
|
|
//
|
||
|
|
// A `ParsedFormat` is a class template representing a preparsed `FormatSpec`,
|
||
|
|
// with template arguments specifying the conversion characters used within the
|
||
|
|
// format string. Such characters must be valid format type specifiers, and
|
||
|
|
// these type specifiers are checked at compile-time.
|
||
|
|
//
|
||
|
|
// Instances of `ParsedFormat` can be created, copied, and reused to speed up
|
||
|
|
// formatting loops. A `ParsedFormat` may either be constructed statically, or
|
||
|
|
// dynamically through its `New()` factory function, which only constructs a
|
||
|
|
// runtime object if the format is valid at that time.
|
||
|
|
//
|
||
|
|
// Example:
|
||
|
|
//
|
||
|
|
// // Verified at compile time.
|
||
|
|
// absl::ParsedFormat<'s', 'd'> formatString("Welcome to %s, Number %d!");
|
||
|
|
// absl::StrFormat(formatString, "TheVillage", 6);
|
||
|
|
//
|
||
|
|
// // Verified at runtime.
|
||
|
|
// auto format_runtime = absl::ParsedFormat<'d'>::New(format_string);
|
||
|
|
// if (format_runtime) {
|
||
|
|
// value = absl::StrFormat(*format_runtime, i);
|
||
|
|
// } else {
|
||
|
|
// ... error case ...
|
||
|
|
// }
|
||
|
|
|
||
|
|
#if defined(__cpp_nontype_template_parameter_auto)
|
||
|
|
// If C++17 is available, an 'extended' format is also allowed that can specify
|
||
|
|
// multiple conversion characters per format argument, using a combination of
|
||
|
|
// `absl::FormatConversionCharSet` enum values (logically a set union)
|
||
|
|
// via the `|` operator. (Single character-based arguments are still accepted,
|
||
|
|
// but cannot be combined). Some common conversions also have predefined enum
|
||
|
|
// values, such as `absl::FormatConversionCharSet::kIntegral`.
|
||
|
|
//
|
||
|
|
// Example:
|
||
|
|
// // Extended format supports multiple conversion characters per argument,
|
||
|
|
// // specified via a combination of `FormatConversionCharSet` enums.
|
||
|
|
// using MyFormat = absl::ParsedFormat<absl::FormatConversionCharSet::d |
|
||
|
|
// absl::FormatConversionCharSet::x>;
|
||
|
|
// MyFormat GetFormat(bool use_hex) {
|
||
|
|
// if (use_hex) return MyFormat("foo %x bar");
|
||
|
|
// return MyFormat("foo %d bar");
|
||
|
|
// }
|
||
|
|
// // `format` can be used with any value that supports 'd' and 'x',
|
||
|
|
// // like `int`.
|
||
|
|
// auto format = GetFormat(use_hex);
|
||
|
|
// value = StringF(format, i);
|
||
|
|
template <auto... Conv>
|
||
|
|
using ParsedFormat = absl::str_format_internal::ExtendedParsedFormat<
|
||
|
|
absl::str_format_internal::ToFormatConversionCharSet(Conv)...>;
|
||
|
|
#else
|
||
|
|
template <char... Conv>
|
||
|
|
using ParsedFormat = str_format_internal::ExtendedParsedFormat<
|
||
|
|
absl::str_format_internal::ToFormatConversionCharSet(Conv)...>;
|
||
|
|
#endif // defined(__cpp_nontype_template_parameter_auto)
|
||
|
|
|
||
|
|
// StrFormat()
|
||
|
|
//
|
||
|
|
// Returns a `string` given a `printf()`-style format string and zero or more
|
||
|
|
// additional arguments. Use it as you would `sprintf()`. `StrFormat()` is the
|
||
|
|
// primary formatting function within the `str_format` library, and should be
|
||
|
|
// used in most cases where you need type-safe conversion of types into
|
||
|
|
// formatted strings.
|
||
|
|
//
|
||
|
|
// The format string generally consists of ordinary character data along with
|
||
|
|
// one or more format conversion specifiers (denoted by the `%` character).
|
||
|
|
// Ordinary character data is returned unchanged into the result string, while
|
||
|
|
// each conversion specification performs a type substitution from
|
||
|
|
// `StrFormat()`'s other arguments. See the comments for `FormatSpec` for full
|
||
|
|
// information on the makeup of this format string.
|
||
|
|
//
|
||
|
|
// Example:
|
||
|
|
//
|
||
|
|
// std::string s = absl::StrFormat(
|
||
|
|
// "Welcome to %s, Number %d!", "The Village", 6);
|
||
|
|
// EXPECT_EQ("Welcome to The Village, Number 6!", s);
|
||
|
|
//
|
||
|
|
// Returns an empty string in case of error.
|
||
|
|
template <typename... Args>
|
||
|
|
ABSL_MUST_USE_RESULT std::string StrFormat(const FormatSpec<Args...>& format,
|
||
|
|
const Args&... args) {
|
||
|
|
return str_format_internal::FormatPack(
|
||
|
|
str_format_internal::UntypedFormatSpecImpl::Extract(format),
|
||
|
|
{str_format_internal::FormatArgImpl(args)...});
|
||
|
|
}
|
||
|
|
|
||
|
|
// StrAppendFormat()
|
||
|
|
//
|
||
|
|
// Appends to a `dst` string given a format string, and zero or more additional
|
||
|
|
// arguments, returning `*dst` as a convenience for chaining purposes. Appends
|
||
|
|
// nothing in case of error (but possibly alters its capacity).
|
||
|
|
//
|
||
|
|
// Example:
|
||
|
|
//
|
||
|
|
// std::string orig("For example PI is approximately ");
|
||
|
|
// std::cout << StrAppendFormat(&orig, "%12.6f", 3.14);
|
||
|
|
template <typename... Args>
|
||
|
|
std::string& StrAppendFormat(std::string* dst,
|
||
|
|
const FormatSpec<Args...>& format,
|
||
|
|
const Args&... args) {
|
||
|
|
return str_format_internal::AppendPack(
|
||
|
|
dst, str_format_internal::UntypedFormatSpecImpl::Extract(format),
|
||
|
|
{str_format_internal::FormatArgImpl(args)...});
|
||
|
|
}
|
||
|
|
|
||
|
|
// StreamFormat()
|
||
|
|
//
|
||
|
|
// Writes to an output stream given a format string and zero or more arguments,
|
||
|
|
// generally in a manner that is more efficient than streaming the result of
|
||
|
|
// `absl:: StrFormat()`. The returned object must be streamed before the full
|
||
|
|
// expression ends.
|
||
|
|
//
|
||
|
|
// Example:
|
||
|
|
//
|
||
|
|
// std::cout << StreamFormat("%12.6f", 3.14);
|
||
|
|
template <typename... Args>
|
||
|
|
ABSL_MUST_USE_RESULT str_format_internal::Streamable StreamFormat(
|
||
|
|
const FormatSpec<Args...>& format, const Args&... args) {
|
||
|
|
return str_format_internal::Streamable(
|
||
|
|
str_format_internal::UntypedFormatSpecImpl::Extract(format),
|
||
|
|
{str_format_internal::FormatArgImpl(args)...});
|
||
|
|
}
|
||
|
|
|
||
|
|
// PrintF()
|
||
|
|
//
|
||
|
|
// Writes to stdout given a format string and zero or more arguments. This
|
||
|
|
// function is functionally equivalent to `std::printf()` (and type-safe);
|
||
|
|
// prefer `absl::PrintF()` over `std::printf()`.
|
||
|
|
//
|
||
|
|
// Example:
|
||
|
|
//
|
||
|
|
// std::string_view s = "Ulaanbaatar";
|
||
|
|
// absl::PrintF("The capital of Mongolia is %s", s);
|
||
|
|
//
|
||
|
|
// Outputs: "The capital of Mongolia is Ulaanbaatar"
|
||
|
|
//
|
||
|
|
template <typename... Args>
|
||
|
|
int PrintF(const FormatSpec<Args...>& format, const Args&... args) {
|
||
|
|
return str_format_internal::FprintF(
|
||
|
|
stdout, str_format_internal::UntypedFormatSpecImpl::Extract(format),
|
||
|
|
{str_format_internal::FormatArgImpl(args)...});
|
||
|
|
}
|
||
|
|
|
||
|
|
// FPrintF()
|
||
|
|
//
|
||
|
|
// Writes to a file given a format string and zero or more arguments. This
|
||
|
|
// function is functionally equivalent to `std::fprintf()` (and type-safe);
|
||
|
|
// prefer `absl::FPrintF()` over `std::fprintf()`.
|
||
|
|
//
|
||
|
|
// Example:
|
||
|
|
//
|
||
|
|
// std::string_view s = "Ulaanbaatar";
|
||
|
|
// absl::FPrintF(stdout, "The capital of Mongolia is %s", s);
|
||
|
|
//
|
||
|
|
// Outputs: "The capital of Mongolia is Ulaanbaatar"
|
||
|
|
//
|
||
|
|
template <typename... Args>
|
||
|
|
int FPrintF(std::FILE* output, const FormatSpec<Args...>& format,
|
||
|
|
const Args&... args) {
|
||
|
|
return str_format_internal::FprintF(
|
||
|
|
output, str_format_internal::UntypedFormatSpecImpl::Extract(format),
|
||
|
|
{str_format_internal::FormatArgImpl(args)...});
|
||
|
|
}
|
||
|
|
|
||
|
|
// SNPrintF()
|
||
|
|
//
|
||
|
|
// Writes to a sized buffer given a format string and zero or more arguments.
|
||
|
|
// This function is functionally equivalent to `std::snprintf()` (and
|
||
|
|
// type-safe); prefer `absl::SNPrintF()` over `std::snprintf()`.
|
||
|
|
//
|
||
|
|
// In particular, a successful call to `absl::SNPrintF()` writes at most `size`
|
||
|
|
// bytes of the formatted output to `output`, including a NUL-terminator, and
|
||
|
|
// returns the number of bytes that would have been written if truncation did
|
||
|
|
// not occur. In the event of an error, a negative value is returned and `errno`
|
||
|
|
// is set.
|
||
|
|
//
|
||
|
|
// Example:
|
||
|
|
//
|
||
|
|
// std::string_view s = "Ulaanbaatar";
|
||
|
|
// char output[128];
|
||
|
|
// absl::SNPrintF(output, sizeof(output),
|
||
|
|
// "The capital of Mongolia is %s", s);
|
||
|
|
//
|
||
|
|
// Post-condition: output == "The capital of Mongolia is Ulaanbaatar"
|
||
|
|
//
|
||
|
|
template <typename... Args>
|
||
|
|
int SNPrintF(char* output, std::size_t size, const FormatSpec<Args...>& format,
|
||
|
|
const Args&... args) {
|
||
|
|
return str_format_internal::SnprintF(
|
||
|
|
output, size, str_format_internal::UntypedFormatSpecImpl::Extract(format),
|
||
|
|
{str_format_internal::FormatArgImpl(args)...});
|
||
|
|
}
|
||
|
|
|
||
|
|
// -----------------------------------------------------------------------------
|
||
|
|
// Custom Output Formatting Functions
|
||
|
|
// -----------------------------------------------------------------------------
|
||
|
|
|
||
|
|
// FormatRawSink
|
||
|
|
//
|
||
|
|
// FormatRawSink is a type erased wrapper around arbitrary sink objects
|
||
|
|
// specifically used as an argument to `Format()`.
|
||
|
|
//
|
||
|
|
// All the object has to do define an overload of `AbslFormatFlush()` for the
|
||
|
|
// sink, usually by adding a ADL-based free function in the same namespace as
|
||
|
|
// the sink:
|
||
|
|
//
|
||
|
|
// void AbslFormatFlush(MySink* dest, absl::string_view part);
|
||
|
|
//
|
||
|
|
// where `dest` is the pointer passed to `absl::Format()`. The function should
|
||
|
|
// append `part` to `dest`.
|
||
|
|
//
|
||
|
|
// FormatRawSink does not own the passed sink object. The passed object must
|
||
|
|
// outlive the FormatRawSink.
|
||
|
|
class FormatRawSink {
|
||
|
|
public:
|
||
|
|
// Implicitly convert from any type that provides the hook function as
|
||
|
|
// described above.
|
||
|
|
template <typename T,
|
||
|
|
typename = typename std::enable_if<std::is_constructible<
|
||
|
|
str_format_internal::FormatRawSinkImpl, T*>::value>::type>
|
||
|
|
FormatRawSink(T* raw) // NOLINT
|
||
|
|
: sink_(raw) {}
|
||
|
|
|
||
|
|
private:
|
||
|
|
friend str_format_internal::FormatRawSinkImpl;
|
||
|
|
str_format_internal::FormatRawSinkImpl sink_;
|
||
|
|
};
|
||
|
|
|
||
|
|
// Format()
|
||
|
|
//
|
||
|
|
// Writes a formatted string to an arbitrary sink object (implementing the
|
||
|
|
// `absl::FormatRawSink` interface), using a format string and zero or more
|
||
|
|
// additional arguments.
|
||
|
|
//
|
||
|
|
// By default, `std::string`, `std::ostream`, and `absl::Cord` are supported as
|
||
|
|
// destination objects. If a `std::string` is used the formatted string is
|
||
|
|
// appended to it.
|
||
|
|
//
|
||
|
|
// `absl::Format()` is a generic version of `absl::StrAppendFormat()`, for
|
||
|
|
// custom sinks. The format string, like format strings for `StrFormat()`, is
|
||
|
|
// checked at compile-time.
|
||
|
|
//
|
||
|
|
// On failure, this function returns `false` and the state of the sink is
|
||
|
|
// unspecified.
|
||
|
|
template <typename... Args>
|
||
|
|
bool Format(FormatRawSink raw_sink, const FormatSpec<Args...>& format,
|
||
|
|
const Args&... args) {
|
||
|
|
return str_format_internal::FormatUntyped(
|
||
|
|
str_format_internal::FormatRawSinkImpl::Extract(raw_sink),
|
||
|
|
str_format_internal::UntypedFormatSpecImpl::Extract(format),
|
||
|
|
{str_format_internal::FormatArgImpl(args)...});
|
||
|
|
}
|
||
|
|
|
||
|
|
// FormatArg
|
||
|
|
//
|
||
|
|
// A type-erased handle to a format argument specifically used as an argument to
|
||
|
|
// `FormatUntyped()`. You may construct `FormatArg` by passing
|
||
|
|
// reference-to-const of any printable type. `FormatArg` is both copyable and
|
||
|
|
// assignable. The source data must outlive the `FormatArg` instance. See
|
||
|
|
// example below.
|
||
|
|
//
|
||
|
|
using FormatArg = str_format_internal::FormatArgImpl;
|
||
|
|
|
||
|
|
// FormatUntyped()
|
||
|
|
//
|
||
|
|
// Writes a formatted string to an arbitrary sink object (implementing the
|
||
|
|
// `absl::FormatRawSink` interface), using an `UntypedFormatSpec` and zero or
|
||
|
|
// more additional arguments.
|
||
|
|
//
|
||
|
|
// This function acts as the most generic formatting function in the
|
||
|
|
// `str_format` library. The caller provides a raw sink, an unchecked format
|
||
|
|
// string, and (usually) a runtime specified list of arguments; no compile-time
|
||
|
|
// checking of formatting is performed within this function. As a result, a
|
||
|
|
// caller should check the return value to verify that no error occurred.
|
||
|
|
// On failure, this function returns `false` and the state of the sink is
|
||
|
|
// unspecified.
|
||
|
|
//
|
||
|
|
// The arguments are provided in an `absl::Span<const absl::FormatArg>`.
|
||
|
|
// Each `absl::FormatArg` object binds to a single argument and keeps a
|
||
|
|
// reference to it. The values used to create the `FormatArg` objects must
|
||
|
|
// outlive this function call.
|
||
|
|
//
|
||
|
|
// Example:
|
||
|
|
//
|
||
|
|
// std::optional<std::string> FormatDynamic(
|
||
|
|
// const std::string& in_format,
|
||
|
|
// const vector<std::string>& in_args) {
|
||
|
|
// std::string out;
|
||
|
|
// std::vector<absl::FormatArg> args;
|
||
|
|
// for (const auto& v : in_args) {
|
||
|
|
// // It is important that 'v' is a reference to the objects in in_args.
|
||
|
|
// // The values we pass to FormatArg must outlive the call to
|
||
|
|
// // FormatUntyped.
|
||
|
|
// args.emplace_back(v);
|
||
|
|
// }
|
||
|
|
// absl::UntypedFormatSpec format(in_format);
|
||
|
|
// if (!absl::FormatUntyped(&out, format, args)) {
|
||
|
|
// return std::nullopt;
|
||
|
|
// }
|
||
|
|
// return std::move(out);
|
||
|
|
// }
|
||
|
|
//
|
||
|
|
ABSL_MUST_USE_RESULT inline bool FormatUntyped(
|
||
|
|
FormatRawSink raw_sink, const UntypedFormatSpec& format,
|
||
|
|
absl::Span<const FormatArg> args) {
|
||
|
|
return str_format_internal::FormatUntyped(
|
||
|
|
str_format_internal::FormatRawSinkImpl::Extract(raw_sink),
|
||
|
|
str_format_internal::UntypedFormatSpecImpl::Extract(format), args);
|
||
|
|
}
|
||
|
|
|
||
|
|
//------------------------------------------------------------------------------
|
||
|
|
// StrFormat Extensions
|
||
|
|
//------------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
// AbslFormatConvert()
|
||
|
|
//
|
||
|
|
// The StrFormat library provides a customization API for formatting
|
||
|
|
// user-defined types using absl::StrFormat(). The API relies on detecting an
|
||
|
|
// overload in the user-defined type's namespace of a free (non-member)
|
||
|
|
// `AbslFormatConvert()` function, usually as a friend definition with the
|
||
|
|
// following signature:
|
||
|
|
//
|
||
|
|
// absl::FormatConvertResult<...> AbslFormatConvert(
|
||
|
|
// const X& value,
|
||
|
|
// const absl::FormatConversionSpec& spec,
|
||
|
|
// absl::FormatSink *sink);
|
||
|
|
//
|
||
|
|
// An `AbslFormatConvert()` overload for a type should only be declared in the
|
||
|
|
// same file and namespace as said type.
|
||
|
|
//
|
||
|
|
// The abstractions within this definition include:
|
||
|
|
//
|
||
|
|
// * An `absl::FormatConversionSpec` to specify the fields to pull from a
|
||
|
|
// user-defined type's format string
|
||
|
|
// * An `absl::FormatSink` to hold the converted string data during the
|
||
|
|
// conversion process.
|
||
|
|
// * An `absl::FormatConvertResult` to hold the status of the returned
|
||
|
|
// formatting operation
|
||
|
|
//
|
||
|
|
// The return type encodes all the conversion characters that your
|
||
|
|
// AbslFormatConvert() routine accepts. The return value should be {true}.
|
||
|
|
// A return value of {false} will result in `StrFormat()` returning
|
||
|
|
// an empty string. This result will be propagated to the result of
|
||
|
|
// `FormatUntyped`.
|
||
|
|
//
|
||
|
|
// Example:
|
||
|
|
//
|
||
|
|
// struct Point {
|
||
|
|
// // To add formatting support to `Point`, we simply need to add a free
|
||
|
|
// // (non-member) function `AbslFormatConvert()`. This method interprets
|
||
|
|
// // `spec` to print in the request format. The allowed conversion characters
|
||
|
|
// // can be restricted via the type of the result, in this example
|
||
|
|
// // string and integral formatting are allowed (but not, for instance
|
||
|
|
// // floating point characters like "%f"). You can add such a free function
|
||
|
|
// // using a friend declaration within the body of the class:
|
||
|
|
// friend absl::FormatConvertResult<absl::FormatConversionCharSet::kString |
|
||
|
|
// absl::FormatConversionCharSet::kIntegral>
|
||
|
|
// AbslFormatConvert(const Point& p, const absl::FormatConversionSpec& spec,
|
||
|
|
// absl::FormatSink* s) {
|
||
|
|
// if (spec.conversion_char() == absl::FormatConversionChar::s) {
|
||
|
|
// s->Append(absl::StrCat("x=", p.x, " y=", p.y));
|
||
|
|
// } else {
|
||
|
|
// s->Append(absl::StrCat(p.x, ",", p.y));
|
||
|
|
// }
|
||
|
|
// return {true};
|
||
|
|
// }
|
||
|
|
//
|
||
|
|
// int x;
|
||
|
|
// int y;
|
||
|
|
// };
|
||
|
|
|
||
|
|
// clang-format off
|
||
|
|
|
||
|
|
// FormatConversionChar
|
||
|
|
//
|
||
|
|
// Specifies the formatting character provided in the format string
|
||
|
|
// passed to `StrFormat()`.
|
||
|
|
enum class FormatConversionChar : uint8_t {
|
||
|
|
c, s, // text
|
||
|
|
d, i, o, u, x, X, // int
|
||
|
|
f, F, e, E, g, G, a, A, // float
|
||
|
|
n, p // misc
|
||
|
|
};
|
||
|
|
// clang-format on
|
||
|
|
|
||
|
|
// FormatConversionSpec
|
||
|
|
//
|
||
|
|
// Specifies modifications to the conversion of the format string, through use
|
||
|
|
// of one or more format flags in the source format string.
|
||
|
|
class FormatConversionSpec {
|
||
|
|
public:
|
||
|
|
// FormatConversionSpec::is_basic()
|
||
|
|
//
|
||
|
|
// Indicates that width and precision are not specified, and no additional
|
||
|
|
// flags are set for this conversion character in the format string.
|
||
|
|
bool is_basic() const { return impl_.is_basic(); }
|
||
|
|
|
||
|
|
// FormatConversionSpec::has_left_flag()
|
||
|
|
//
|
||
|
|
// Indicates whether the result should be left justified for this conversion
|
||
|
|
// character in the format string. This flag is set through use of a '-'
|
||
|
|
// character in the format string. E.g. "%-s"
|
||
|
|
bool has_left_flag() const { return impl_.has_left_flag(); }
|
||
|
|
|
||
|
|
// FormatConversionSpec::has_show_pos_flag()
|
||
|
|
//
|
||
|
|
// Indicates whether a sign column is prepended to the result for this
|
||
|
|
// conversion character in the format string, even if the result is positive.
|
||
|
|
// This flag is set through use of a '+' character in the format string.
|
||
|
|
// E.g. "%+d"
|
||
|
|
bool has_show_pos_flag() const { return impl_.has_show_pos_flag(); }
|
||
|
|
|
||
|
|
// FormatConversionSpec::has_sign_col_flag()
|
||
|
|
//
|
||
|
|
// Indicates whether a mandatory sign column is added to the result for this
|
||
|
|
// conversion character. This flag is set through use of a space character
|
||
|
|
// (' ') in the format string. E.g. "% i"
|
||
|
|
bool has_sign_col_flag() const { return impl_.has_sign_col_flag(); }
|
||
|
|
|
||
|
|
// FormatConversionSpec::has_alt_flag()
|
||
|
|
//
|
||
|
|
// Indicates whether an "alternate" format is applied to the result for this
|
||
|
|
// conversion character. Alternative forms depend on the type of conversion
|
||
|
|
// character, and unallowed alternatives are undefined. This flag is set
|
||
|
|
// through use of a '#' character in the format string. E.g. "%#h"
|
||
|
|
bool has_alt_flag() const { return impl_.has_alt_flag(); }
|
||
|
|
|
||
|
|
// FormatConversionSpec::has_zero_flag()
|
||
|
|
//
|
||
|
|
// Indicates whether zeroes should be prepended to the result for this
|
||
|
|
// conversion character instead of spaces. This flag is set through use of the
|
||
|
|
// '0' character in the format string. E.g. "%0f"
|
||
|
|
bool has_zero_flag() const { return impl_.has_zero_flag(); }
|
||
|
|
|
||
|
|
// FormatConversionSpec::conversion_char()
|
||
|
|
//
|
||
|
|
// Returns the underlying conversion character.
|
||
|
|
FormatConversionChar conversion_char() const {
|
||
|
|
return impl_.conversion_char();
|
||
|
|
}
|
||
|
|
|
||
|
|
// FormatConversionSpec::width()
|
||
|
|
//
|
||
|
|
// Returns the specified width (indicated through use of a non-zero integer
|
||
|
|
// value or '*' character) of the conversion character. If width is
|
||
|
|
// unspecified, it returns a negative value.
|
||
|
|
int width() const { return impl_.width(); }
|
||
|
|
|
||
|
|
// FormatConversionSpec::precision()
|
||
|
|
//
|
||
|
|
// Returns the specified precision (through use of the '.' character followed
|
||
|
|
// by a non-zero integer value or '*' character) of the conversion character.
|
||
|
|
// If precision is unspecified, it returns a negative value.
|
||
|
|
int precision() const { return impl_.precision(); }
|
||
|
|
|
||
|
|
private:
|
||
|
|
explicit FormatConversionSpec(
|
||
|
|
str_format_internal::FormatConversionSpecImpl impl)
|
||
|
|
: impl_(impl) {}
|
||
|
|
|
||
|
|
friend str_format_internal::FormatConversionSpecImpl;
|
||
|
|
|
||
|
|
absl::str_format_internal::FormatConversionSpecImpl impl_;
|
||
|
|
};
|
||
|
|
|
||
|
|
// Type safe OR operator for FormatConversionCharSet to allow accepting multiple
|
||
|
|
// conversion chars in custom format converters.
|
||
|
|
constexpr FormatConversionCharSet operator|(FormatConversionCharSet a,
|
||
|
|
FormatConversionCharSet b) {
|
||
|
|
return static_cast<FormatConversionCharSet>(static_cast<uint64_t>(a) |
|
||
|
|
static_cast<uint64_t>(b));
|
||
|
|
}
|
||
|
|
|
||
|
|
// FormatConversionCharSet
|
||
|
|
//
|
||
|
|
// Specifies the _accepted_ conversion types as a template parameter to
|
||
|
|
// FormatConvertResult for custom implementations of `AbslFormatConvert`.
|
||
|
|
// Note the helper predefined alias definitions (kIntegral, etc.) below.
|
||
|
|
enum class FormatConversionCharSet : uint64_t {
|
||
|
|
// text
|
||
|
|
c = str_format_internal::FormatConversionCharToConvInt('c'),
|
||
|
|
s = str_format_internal::FormatConversionCharToConvInt('s'),
|
||
|
|
// integer
|
||
|
|
d = str_format_internal::FormatConversionCharToConvInt('d'),
|
||
|
|
i = str_format_internal::FormatConversionCharToConvInt('i'),
|
||
|
|
o = str_format_internal::FormatConversionCharToConvInt('o'),
|
||
|
|
u = str_format_internal::FormatConversionCharToConvInt('u'),
|
||
|
|
x = str_format_internal::FormatConversionCharToConvInt('x'),
|
||
|
|
X = str_format_internal::FormatConversionCharToConvInt('X'),
|
||
|
|
// Float
|
||
|
|
f = str_format_internal::FormatConversionCharToConvInt('f'),
|
||
|
|
F = str_format_internal::FormatConversionCharToConvInt('F'),
|
||
|
|
e = str_format_internal::FormatConversionCharToConvInt('e'),
|
||
|
|
E = str_format_internal::FormatConversionCharToConvInt('E'),
|
||
|
|
g = str_format_internal::FormatConversionCharToConvInt('g'),
|
||
|
|
G = str_format_internal::FormatConversionCharToConvInt('G'),
|
||
|
|
a = str_format_internal::FormatConversionCharToConvInt('a'),
|
||
|
|
A = str_format_internal::FormatConversionCharToConvInt('A'),
|
||
|
|
// misc
|
||
|
|
n = str_format_internal::FormatConversionCharToConvInt('n'),
|
||
|
|
p = str_format_internal::FormatConversionCharToConvInt('p'),
|
||
|
|
|
||
|
|
// Used for width/precision '*' specification.
|
||
|
|
kStar = static_cast<uint64_t>(
|
||
|
|
absl::str_format_internal::FormatConversionCharSetInternal::kStar),
|
||
|
|
// Some predefined values:
|
||
|
|
kIntegral = d | i | u | o | x | X,
|
||
|
|
kFloating = a | e | f | g | A | E | F | G,
|
||
|
|
kNumeric = kIntegral | kFloating,
|
||
|
|
kString = s,
|
||
|
|
kPointer = p,
|
||
|
|
};
|
||
|
|
|
||
|
|
// FormatSink
|
||
|
|
//
|
||
|
|
// An abstraction to which conversions write their string data.
|
||
|
|
//
|
||
|
|
class FormatSink {
|
||
|
|
public:
|
||
|
|
// Appends `count` copies of `ch`.
|
||
|
|
void Append(size_t count, char ch) { sink_->Append(count, ch); }
|
||
|
|
|
||
|
|
void Append(string_view v) { sink_->Append(v); }
|
||
|
|
|
||
|
|
// Appends the first `precision` bytes of `v`. If this is less than
|
||
|
|
// `width`, spaces will be appended first (if `left` is false), or
|
||
|
|
// after (if `left` is true) to ensure the total amount appended is
|
||
|
|
// at least `width`.
|
||
|
|
bool PutPaddedString(string_view v, int width, int precision, bool left) {
|
||
|
|
return sink_->PutPaddedString(v, width, precision, left);
|
||
|
|
}
|
||
|
|
|
||
|
|
private:
|
||
|
|
friend str_format_internal::FormatSinkImpl;
|
||
|
|
explicit FormatSink(str_format_internal::FormatSinkImpl* s) : sink_(s) {}
|
||
|
|
str_format_internal::FormatSinkImpl* sink_;
|
||
|
|
};
|
||
|
|
|
||
|
|
// FormatConvertResult
|
||
|
|
//
|
||
|
|
// Indicates whether a call to AbslFormatConvert() was successful.
|
||
|
|
// This return type informs the StrFormat extension framework (through
|
||
|
|
// ADL but using the return type) of what conversion characters are supported.
|
||
|
|
// It is strongly discouraged to return {false}, as this will result in an
|
||
|
|
// empty string in StrFormat.
|
||
|
|
template <FormatConversionCharSet C>
|
||
|
|
struct FormatConvertResult {
|
||
|
|
bool value;
|
||
|
|
};
|
||
|
|
|
||
|
|
ABSL_NAMESPACE_END
|
||
|
|
} // namespace absl
|
||
|
|
|
||
|
|
#endif // ABSL_STRINGS_STR_FORMAT_H_
|