|
|
|
//
|
|
|
|
// Copyright 2017 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: substitute.h
|
|
|
|
// -----------------------------------------------------------------------------
|
|
|
|
//
|
|
|
|
// This package contains functions for efficiently performing string
|
|
|
|
// substitutions using a format string with positional notation:
|
|
|
|
// `Substitute()` and `SubstituteAndAppend()`.
|
|
|
|
//
|
|
|
|
// Unlike printf-style format specifiers, `Substitute()` functions do not need
|
|
|
|
// to specify the type of the substitution arguments. Supported arguments
|
|
|
|
// following the format string, such as strings, string_views, ints,
|
|
|
|
// floats, and bools, are automatically converted to strings during the
|
|
|
|
// substitution process. (See below for a full list of supported types.)
|
|
|
|
//
|
|
|
|
// `Substitute()` does not allow you to specify *how* to format a value, beyond
|
|
|
|
// the default conversion to string. For example, you cannot format an integer
|
|
|
|
// in hex.
|
|
|
|
//
|
|
|
|
// The format string uses positional identifiers indicated by a dollar sign ($)
|
|
|
|
// and single digit positional ids to indicate which substitution arguments to
|
|
|
|
// use at that location within the format string.
|
|
|
|
//
|
|
|
|
// A '$$' sequence in the format string causes a literal '$' character to be
|
|
|
|
// output.
|
|
|
|
//
|
|
|
|
// Example 1:
|
|
|
|
// std::string s = Substitute("$1 purchased $0 $2 for $$10. Thanks $1!",
|
|
|
|
// 5, "Bob", "Apples");
|
|
|
|
// EXPECT_EQ("Bob purchased 5 Apples for $10. Thanks Bob!", s);
|
|
|
|
//
|
|
|
|
// Example 2:
|
|
|
|
// std::string s = "Hi. ";
|
|
|
|
// SubstituteAndAppend(&s, "My name is $0 and I am $1 years old.", "Bob", 5);
|
|
|
|
// EXPECT_EQ("Hi. My name is Bob and I am 5 years old.", s);
|
|
|
|
//
|
|
|
|
// Supported types:
|
|
|
|
// * absl::string_view, std::string, const char* (null is equivalent to "")
|
|
|
|
// * int32_t, int64_t, uint32_t, uint64_t
|
|
|
|
// * float, double
|
|
|
|
// * bool (Printed as "true" or "false")
|
|
|
|
// * pointer types other than char* (Printed as "0x<lower case hex string>",
|
|
|
|
// except that null is printed as "NULL")
|
|
|
|
// * user-defined types via the `AbslStringify()` customization point. See the
|
|
|
|
// documentation for `absl::StrCat` for an explanation on how to use this.
|
|
|
|
//
|
|
|
|
// If an invalid format string is provided, Substitute returns an empty string
|
|
|
|
// and SubstituteAndAppend does not change the provided output string.
|
|
|
|
// A format string is invalid if it:
|
|
|
|
// * ends in an unescaped $ character,
|
|
|
|
// e.g. "Hello $", or
|
|
|
|
// * calls for a position argument which is not provided,
|
|
|
|
// e.g. Substitute("Hello $2", "world"), or
|
|
|
|
// * specifies a non-digit, non-$ character after an unescaped $ character,
|
|
|
|
// e.g. "Hello $f".
|
|
|
|
// In debug mode, i.e. #ifndef NDEBUG, such errors terminate the program.
|
|
|
|
|
|
|
|
#ifndef ABSL_STRINGS_SUBSTITUTE_H_
|
|
|
|
#define ABSL_STRINGS_SUBSTITUTE_H_
|
|
|
|
|
|
|
|
#include <cstring>
|
|
|
|
#include <string>
|
|
|
|
#include <type_traits>
|
|
|
|
#include <vector>
|
|
|
|
|
|
|
|
#include "absl/base/macros.h"
|
|
|
|
#include "absl/base/port.h"
|
|
|
|
#include "absl/strings/ascii.h"
|
|
|
|
#include "absl/strings/escaping.h"
|
|
|
|
#include "absl/strings/internal/stringify_sink.h"
|
|
|
|
#include "absl/strings/numbers.h"
|
|
|
|
#include "absl/strings/str_cat.h"
|
|
|
|
#include "absl/strings/str_split.h"
|
|
|
|
#include "absl/strings/string_view.h"
|
|
|
|
#include "absl/strings/strip.h"
|
|
|
|
|
|
|
|
namespace absl {
|
|
|
|
ABSL_NAMESPACE_BEGIN
|
|
|
|
namespace substitute_internal {
|
|
|
|
|
|
|
|
// Arg
|
|
|
|
//
|
|
|
|
// This class provides an argument type for `absl::Substitute()` and
|
|
|
|
// `absl::SubstituteAndAppend()`. `Arg` handles implicit conversion of various
|
|
|
|
// types to a string. (`Arg` is very similar to the `AlphaNum` class in
|
|
|
|
// `StrCat()`.)
|
|
|
|
//
|
|
|
|
// This class has implicit constructors.
|
|
|
|
class Arg {
|
|
|
|
public:
|
|
|
|
// Overloads for string-y things
|
|
|
|
//
|
|
|
|
// Explicitly overload `const char*` so the compiler doesn't cast to `bool`.
|
|
|
|
Arg(const char* value) // NOLINT(google-explicit-constructor)
|
|
|
|
: piece_(absl::NullSafeStringView(value)) {}
|
|
|
|
template <typename Allocator>
|
|
|
|
Arg( // NOLINT
|
|
|
|
const std::basic_string<char, std::char_traits<char>, Allocator>&
|
|
|
|
value) noexcept
|
|
|
|
: piece_(value) {}
|
|
|
|
Arg(absl::string_view value) // NOLINT(google-explicit-constructor)
|
|
|
|
: piece_(value) {}
|
|
|
|
|
|
|
|
// Overloads for primitives
|
|
|
|
//
|
|
|
|
// No overloads are available for signed and unsigned char because if people
|
|
|
|
// are explicitly declaring their chars as signed or unsigned then they are
|
|
|
|
// probably using them as 8-bit integers and would probably prefer an integer
|
|
|
|
// representation. However, we can't really know, so we make the caller decide
|
|
|
|
// what to do.
|
|
|
|
Arg(char value) // NOLINT(google-explicit-constructor)
|
|
|
|
: piece_(scratch_, 1) {
|
|
|
|
scratch_[0] = value;
|
|
|
|
}
|
|
|
|
Arg(short value) // NOLINT(*)
|
|
|
|
: piece_(scratch_,
|
|
|
|
static_cast<size_t>(
|
|
|
|
numbers_internal::FastIntToBuffer(value, scratch_) -
|
|
|
|
scratch_)) {}
|
|
|
|
Arg(unsigned short value) // NOLINT(*)
|
|
|
|
: piece_(scratch_,
|
|
|
|
static_cast<size_t>(
|
|
|
|
numbers_internal::FastIntToBuffer(value, scratch_) -
|
|
|
|
scratch_)) {}
|
|
|
|
Arg(int value) // NOLINT(google-explicit-constructor)
|
|
|
|
: piece_(scratch_,
|
|
|
|
static_cast<size_t>(
|
|
|
|
numbers_internal::FastIntToBuffer(value, scratch_) -
|
|
|
|
scratch_)) {}
|
|
|
|
Arg(unsigned int value) // NOLINT(google-explicit-constructor)
|
|
|
|
: piece_(scratch_,
|
|
|
|
static_cast<size_t>(
|
|
|
|
numbers_internal::FastIntToBuffer(value, scratch_) -
|
|
|
|
scratch_)) {}
|
|
|
|
Arg(long value) // NOLINT(*)
|
|
|
|
: piece_(scratch_,
|
|
|
|
static_cast<size_t>(
|
|
|
|
numbers_internal::FastIntToBuffer(value, scratch_) -
|
|
|
|
scratch_)) {}
|
|
|
|
Arg(unsigned long value) // NOLINT(*)
|
|
|
|
: piece_(scratch_,
|
|
|
|
static_cast<size_t>(
|
|
|
|
numbers_internal::FastIntToBuffer(value, scratch_) -
|
|
|
|
scratch_)) {}
|
|
|
|
Arg(long long value) // NOLINT(*)
|
|
|
|
: piece_(scratch_,
|
|
|
|
static_cast<size_t>(
|
|
|
|
numbers_internal::FastIntToBuffer(value, scratch_) -
|
|
|
|
scratch_)) {}
|
|
|
|
Arg(unsigned long long value) // NOLINT(*)
|
|
|
|
: piece_(scratch_,
|
|
|
|
static_cast<size_t>(
|
|
|
|
numbers_internal::FastIntToBuffer(value, scratch_) -
|
|
|
|
scratch_)) {}
|
|
|
|
Arg(float value) // NOLINT(google-explicit-constructor)
|
|
|
|
: piece_(scratch_, numbers_internal::SixDigitsToBuffer(value, scratch_)) {
|
|
|
|
}
|
|
|
|
Arg(double value) // NOLINT(google-explicit-constructor)
|
|
|
|
: piece_(scratch_, numbers_internal::SixDigitsToBuffer(value, scratch_)) {
|
|
|
|
}
|
|
|
|
Arg(bool value) // NOLINT(google-explicit-constructor)
|
|
|
|
: piece_(value ? "true" : "false") {}
|
|
|
|
|
|
|
|
template <typename T, typename = typename std::enable_if<
|
|
|
|
strings_internal::HasAbslStringify<T>::value>::type>
|
|
|
|
Arg( // NOLINT(google-explicit-constructor)
|
|
|
|
const T& v, strings_internal::StringifySink&& sink = {})
|
|
|
|
: piece_(strings_internal::ExtractStringification(sink, v)) {}
|
|
|
|
|
|
|
|
Arg(Hex hex); // NOLINT(google-explicit-constructor)
|
|
|
|
Arg(Dec dec); // NOLINT(google-explicit-constructor)
|
|
|
|
|
Export of internal Abseil changes
--
07240ca7822d007cdcc79f2c40bd58b2c2010348 by Abseil Team <absl-team@google.com>:
Correct the comment from "AlphaNum" to "Arg".
PiperOrigin-RevId: 416139192
--
adcba4a6b3763626e1db7b1e8c108b3114903557 by Martijn Vels <mvels@google.com>:
Fix NewExternalRep() to require data being non-empty, and remove nullptr return.
PiperOrigin-RevId: 416135865
--
c0d14cd918fb16f15d1d84de9284b5c5ecc1f8f2 by Abseil Team <absl-team@google.com>:
Fix doc comment for absl::ascii_isprint().
The comment was incorrectly saying that it includes all whitespace.
It doesn't; the only whitespace char it includes is ' '.
PiperOrigin-RevId: 416112524
--
d83327800159c07002b6865e21232a12463e02dd by Abseil Team <absl-team@google.com>:
Internal change
PiperOrigin-RevId: 416099978
--
baf11e9ca42ca9140cdbf8075f971db8d65b1195 by Ilya Tokar <tokarip@google.com>:
Prevent compiler from optimizing Group_Match* benchmarks away.
Currently we benchmark single store of precomputed value.
Not all affected benchmarks show performance changes:
BM_Group_Match 0.53ns ± 1% 0.53ns ± 0% -0.42% (p=0.038 n=10+10)
BM_Group_MatchEmpty 0.26ns ± 1% 0.26ns ± 1% ~ (p=1.000 n=10+10)
BM_Group_MatchEmptyOrDeleted 0.26ns ± 1% 0.26ns ± 1% ~ (p=0.121 n=10+10)
BM_Group_CountLeadingEmptyOrDeleted 0.26ns ± 1% 0.45ns ± 0% +70.05% (p=0.000 n=10+8)
BM_Group_MatchFirstEmptyOrDeleted 0.26ns ± 0% 0.44ns ± 1% +65.91% (p=0.000 n=8+9)
But inspecting the generated code shows the difference,
e. g. BM_Group_MatchFirstEmptyOrDeleted
Before:
add $0xffffffffffffffff,%rbx
jne 30
After:
pcmpeqd %xmm0,%xmm0
pcmpgtb -0x30(%rbp),%xmm0
pmovmskb %xmm0,%eax
add: 0x23$0xffffffffffffffff,%rbx
jne 40
PiperOrigin-RevId: 416083515
--
122fbff893dc4571b3e75e4b241eb4495b925610 by Abseil Team <absl-team@google.com>:
Put namespace guard in ABSL_DECLARE_FLAG to make declaring a flag in a namespace a compiler error instead of a linker error.
PiperOrigin-RevId: 416036072
--
020fd8a20f5fa319e948846e003391fcb9e03868 by Ilya Tokar <tokarip@google.com>:
Make Cord::InlineRep::set_data unconditionally zero out memory.
Currently there is a single case where we don't zero out memory
as an optimization. Unconditional zeroing doesn't show any changes
in benchmarks, except for the unrelated improvement:
BM_CordPartialCopyToCord/1M/1 12.6ns ± 4% 12.6ns ± 4% ~ (p=0.857 n=16+19)
BM_CordPartialCopyToCord/1M/128 44.9ns ± 7% 45.0ns ± 3% ~ (p=0.468 n=18+17)
BM_CordPartialCopyToCord/1M/1k 64.5ns ± 4% 61.4ns ± 4% -4.82% (p=0.000 n=19+17)
BM_CordPartialCopyToCord/1M/8k 139ns ± 3% 128ns ±15% -7.76% (p=0.009 n=17+20)
BM_CordPartialCopyToCord/1M/16k 193ns ± 6% 168ns ± 6% -13.17% (p=0.000 n=17+17)
BM_CordPartialCopyToCord/4M/16k 199ns ± 4% 177ns ± 4% -11.36% (p=0.000 n=17+18)
BM_CordPartialCopyToCord/4M/32k 275ns ± 3% 250ns ± 4% -9.00% (p=0.000 n=18+18)
BM_CordPartialCopyToCord/4M/64k 291ns ± 4% 266ns ± 5% -8.53% (p=0.000 n=18+16)
BM_CordPartialCopyToCord/4M/128k 322ns ± 5% 291ns ± 4% -9.43% (p=0.000 n=20+18)
BM_CordPartialCopyToCord/8M/32k 281ns ± 5% 251ns ± 4% -10.38% (p=0.000 n=20+16)
BM_CordPartialCopyToCord/8M/64k 293ns ± 6% 267ns ± 4% -8.87% (p=0.000 n=16+19)
BM_CordPartialCopyToCord/8M/128k 334ns ± 3% 305ns ± 2% -8.56% (p=0.000 n=17+16)
This is clearly an alignmnet effect since number of the executed instructions is the same:
M_CordPartialCopyToCord/1M/1 155 ± 0% 155 ± 0% ~ (all samples are equal)
BM_CordPartialCopyToCord/1M/128 446 ± 0% 446 ± 0% ~ (p=0.332 n=36+39)
BM_CordPartialCopyToCord/1M/1k 473 ± 0% 473 ± 0% ~ (p=0.969 n=40+40)
BM_CordPartialCopyToCord/1M/8k 808 ± 0% 808 ± 0% ~ (p=0.127 n=40+39)
BM_CordPartialCopyToCord/1M/16k 957 ± 0% 957 ± 0% ~ (p=0.532 n=40+40)
BM_CordPartialCopyToCord/4M/16k 952 ± 0% 952 ± 0% ~ (p=0.686 n=39+39)
BM_CordPartialCopyToCord/4M/32k 1.12k ± 0% 1.12k ± 0% ~ (p=0.690 n=40+40)
BM_CordPartialCopyToCord/4M/64k 1.23k ± 0% 1.23k ± 0% ~ (p=0.182 n=40+39)
BM_CordPartialCopyToCord/4M/128k 1.44k ± 0% 1.44k ± 0% ~ (p=0.711 n=40+40)
BM_CordPartialCopyToCord/8M/32k 1.12k ± 0% 1.12k ± 0% ~ (p=0.697 n=40+40)
BM_CordPartialCopyToCord/8M/64k 1.23k ± 0% 1.23k ± 0% +0.00% (p=0.049 n=40+40)
BM_CordPartialCopyToCord/8M/128k 1.44k ± 0% 1.44k ± 0% ~ (p=0.507 n=40+40)
This makes code simpler and doesn't regress performance.
PiperOrigin-RevId: 415560574
--
37305b2690b31682088749e4d62f40d7095bdc54 by Derek Mauro <dmauro@google.com>:
Internal change
PiperOrigin-RevId: 415558737
--
86aaed569b9e743c1eb813a5f48def978a793db3 by Martijn Vels <mvels@google.com>:
Internal change
PiperOrigin-RevId: 415515201
--
6cdb8786cdcb4fa0b8a4b72fc98940877d1fdeff by Abseil Team <absl-team@google.com>:
Update SubmitMutexProfileData to accept wait_cycles instead of wait_timestamp
PiperOrigin-RevId: 415360871
--
9f979d307aa16ad09f214e04876cbe84395c0901 by Abseil Team <absl-team@google.com>:
absl::flat_hash_set compiles with -Wconversion -Wsign-compare
PiperOrigin-RevId: 415357498
--
9eceb14174708f15e61259d449b214a8a4c7f9e7 by Abseil Team <absl-team@google.com>:
Fix AddressIsReadable for the corner case of (aligned) addr == NULL.
PiperOrigin-RevId: 415307792
--
1a39ffe55898375e2d7f88c17c99db5a1b95b313 by Martijn Vels <mvels@google.com>:
Internal change
PiperOrigin-RevId: 415162872
--
64378549b110d5f5762185a5906c520fba70f0e7 by Abseil Team <absl-team@google.com>:
Fix a typo in the comments
PiperOrigin-RevId: 415088461
--
41aae8322e913b82710153c22b97c611fdb6e1fb by Abseil Team <absl-team@google.com>:
Switch from `connect` to `rt_sigreturn` -- the latter is much less problematic
for system call sandboxes.
PiperOrigin-RevId: 415073965
--
870c5e3388b6a35611bff538626fe7a1c8c87171 by Abseil Team <absl-team@google.com>:
Add ABSL_HAVE_HWADDRESS_SANITIZER and ABSL_HAVE_LEAK_SANITIZER
PiperOrigin-RevId: 414871189
--
f213ed60a66b58da7ac40555adfb1d529ff0a4db by Derek Mauro <dmauro@google.com>:
Remove reference to __SANITIZE_MEMORY__, which does not exist
It appears to have been copied by pattern matching from the ASAN/TSAN
code blocks.
https://github.com/gcc-mirror/gcc/blob/f47662204de27f7685699eeef89aa173ccf32d85/gcc/cppbuiltin.c#L79-L126
PiperOrigin-RevId: 414806587
--
b152891e73ab515f397ceb53f66c8ee2f33863ea by Abseil Team <absl-team@google.com>:
Rollback previous commit: SYS_open is not defined in certain environments.
PiperOrigin-RevId: 414521820
--
5a1cbb282331023902e1374dd0d920c4effbe47f by Abseil Team <absl-team@google.com>:
Use syscall(SYS_open, ...) instead of open() to avoid possible symbol
interposition.
Also add some warning notes.
PiperOrigin-RevId: 414508186
--
1824d6593612710aafdc599a89b0adced7d787f6 by Abseil Team <absl-team@google.com>:
Correct aarch64 macro check
The macro is __aarch64__, not __arch64__.
PiperOrigin-RevId: 414446225
--
a1536a57b64dfd53945d33a01cfc08b18c99c97b by Abseil Team <absl-team@google.com>:
Fix backwards comment in the last commit.
PiperOrigin-RevId: 414281214
--
11ac021ba779513667a31cf2563ddafc57d6d913 by Abseil Team <absl-team@google.com>:
AddressIsReadable() didn't work correctly on ARM when the given pointer was
misaligned at the end of the page.
Fix that by aligning the pointer on an 8-byte boundary before checking it.
PiperOrigin-RevId: 414203863
GitOrigin-RevId: 07240ca7822d007cdcc79f2c40bd58b2c2010348
Change-Id: If5f129194d59f5c9e5d84efd8cd9e17a70e072ab
3 years ago
|
|
|
// vector<bool>::reference and const_reference require special help to convert
|
|
|
|
// to `Arg` because it requires two user defined conversions.
|
|
|
|
template <typename T,
|
|
|
|
absl::enable_if_t<
|
|
|
|
std::is_class<T>::value &&
|
|
|
|
(std::is_same<T, std::vector<bool>::reference>::value ||
|
|
|
|
std::is_same<T, std::vector<bool>::const_reference>::value)>* =
|
|
|
|
nullptr>
|
|
|
|
Arg(T value) // NOLINT(google-explicit-constructor)
|
|
|
|
: Arg(static_cast<bool>(value)) {}
|
|
|
|
|
|
|
|
// `void*` values, with the exception of `char*`, are printed as
|
|
|
|
// "0x<hex value>". However, in the case of `nullptr`, "NULL" is printed.
|
|
|
|
Arg(const void* value); // NOLINT(google-explicit-constructor)
|
|
|
|
|
|
|
|
// Normal enums are already handled by the integer formatters.
|
|
|
|
// This overload matches only scoped enums.
|
|
|
|
template <typename T,
|
|
|
|
typename = typename std::enable_if<
|
|
|
|
std::is_enum<T>{} && !std::is_convertible<T, int>{}>::type>
|
|
|
|
Arg(T value) // NOLINT(google-explicit-constructor)
|
|
|
|
: Arg(static_cast<typename std::underlying_type<T>::type>(value)) {}
|
|
|
|
|
|
|
|
Arg(const Arg&) = delete;
|
|
|
|
Arg& operator=(const Arg&) = delete;
|
|
|
|
|
|
|
|
absl::string_view piece() const { return piece_; }
|
|
|
|
|
|
|
|
private:
|
|
|
|
absl::string_view piece_;
|
|
|
|
char scratch_[numbers_internal::kFastToBufferSize];
|
|
|
|
};
|
|
|
|
|
|
|
|
// Internal helper function. Don't call this from outside this implementation.
|
|
|
|
// This interface may change without notice.
|
|
|
|
void SubstituteAndAppendArray(std::string* output, absl::string_view format,
|
|
|
|
const absl::string_view* args_array,
|
|
|
|
size_t num_args);
|
|
|
|
|
|
|
|
#if defined(ABSL_BAD_CALL_IF)
|
|
|
|
constexpr int CalculateOneBit(const char* format) {
|
|
|
|
// Returns:
|
|
|
|
// * 2^N for '$N' when N is in [0-9]
|
|
|
|
// * 0 for correct '$' escaping: '$$'.
|
|
|
|
// * -1 otherwise.
|
|
|
|
return (*format < '0' || *format > '9') ? (*format == '$' ? 0 : -1)
|
|
|
|
: (1 << (*format - '0'));
|
|
|
|
}
|
|
|
|
|
|
|
|
constexpr const char* SkipNumber(const char* format) {
|
|
|
|
return !*format ? format : (format + 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
constexpr int PlaceholderBitmask(const char* format) {
|
|
|
|
return !*format
|
|
|
|
? 0
|
|
|
|
: *format != '$' ? PlaceholderBitmask(format + 1)
|
|
|
|
: (CalculateOneBit(format + 1) |
|
|
|
|
PlaceholderBitmask(SkipNumber(format + 1)));
|
|
|
|
}
|
|
|
|
#endif // ABSL_BAD_CALL_IF
|
|
|
|
|
|
|
|
} // namespace substitute_internal
|
|
|
|
|
|
|
|
//
|
|
|
|
// PUBLIC API
|
|
|
|
//
|
|
|
|
|
|
|
|
// SubstituteAndAppend()
|
|
|
|
//
|
|
|
|
// Substitutes variables into a given format string and appends to a given
|
|
|
|
// output string. See file comments above for usage.
|
|
|
|
//
|
|
|
|
// The declarations of `SubstituteAndAppend()` below consist of overloads
|
|
|
|
// for passing 0 to 10 arguments, respectively.
|
|
|
|
//
|
|
|
|
// NOTE: A zero-argument `SubstituteAndAppend()` may be used within variadic
|
|
|
|
// templates to allow a variable number of arguments.
|
|
|
|
//
|
|
|
|
// Example:
|
|
|
|
// template <typename... Args>
|
|
|
|
// void VarMsg(std::string* boilerplate, absl::string_view format,
|
|
|
|
// const Args&... args) {
|
|
|
|
// absl::SubstituteAndAppend(boilerplate, format, args...);
|
|
|
|
// }
|
|
|
|
//
|
|
|
|
inline void SubstituteAndAppend(std::string* output, absl::string_view format) {
|
|
|
|
substitute_internal::SubstituteAndAppendArray(output, format, nullptr, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
inline void SubstituteAndAppend(std::string* output, absl::string_view format,
|
|
|
|
const substitute_internal::Arg& a0) {
|
|
|
|
const absl::string_view args[] = {a0.piece()};
|
|
|
|
substitute_internal::SubstituteAndAppendArray(output, format, args,
|
|
|
|
ABSL_ARRAYSIZE(args));
|
|
|
|
}
|
|
|
|
|
|
|
|
inline void SubstituteAndAppend(std::string* output, absl::string_view format,
|
|
|
|
const substitute_internal::Arg& a0,
|
|
|
|
const substitute_internal::Arg& a1) {
|
|
|
|
const absl::string_view args[] = {a0.piece(), a1.piece()};
|
|
|
|
substitute_internal::SubstituteAndAppendArray(output, format, args,
|
|
|
|
ABSL_ARRAYSIZE(args));
|
|
|
|
}
|
|
|
|
|
|
|
|
inline void SubstituteAndAppend(std::string* output, absl::string_view format,
|
|
|
|
const substitute_internal::Arg& a0,
|
|
|
|
const substitute_internal::Arg& a1,
|
|
|
|
const substitute_internal::Arg& a2) {
|
|
|
|
const absl::string_view args[] = {a0.piece(), a1.piece(), a2.piece()};
|
|
|
|
substitute_internal::SubstituteAndAppendArray(output, format, args,
|
|
|
|
ABSL_ARRAYSIZE(args));
|
|
|
|
}
|
|
|
|
|
|
|
|
inline void SubstituteAndAppend(std::string* output, absl::string_view format,
|
|
|
|
const substitute_internal::Arg& a0,
|
|
|
|
const substitute_internal::Arg& a1,
|
|
|
|
const substitute_internal::Arg& a2,
|
|
|
|
const substitute_internal::Arg& a3) {
|
|
|
|
const absl::string_view args[] = {a0.piece(), a1.piece(), a2.piece(),
|
|
|
|
a3.piece()};
|
|
|
|
substitute_internal::SubstituteAndAppendArray(output, format, args,
|
|
|
|
ABSL_ARRAYSIZE(args));
|
|
|
|
}
|
|
|
|
|
|
|
|
inline void SubstituteAndAppend(std::string* output, absl::string_view format,
|
|
|
|
const substitute_internal::Arg& a0,
|
|
|
|
const substitute_internal::Arg& a1,
|
|
|
|
const substitute_internal::Arg& a2,
|
|
|
|
const substitute_internal::Arg& a3,
|
|
|
|
const substitute_internal::Arg& a4) {
|
|
|
|
const absl::string_view args[] = {a0.piece(), a1.piece(), a2.piece(),
|
|
|
|
a3.piece(), a4.piece()};
|
|
|
|
substitute_internal::SubstituteAndAppendArray(output, format, args,
|
|
|
|
ABSL_ARRAYSIZE(args));
|
|
|
|
}
|
|
|
|
|
|
|
|
inline void SubstituteAndAppend(std::string* output, absl::string_view format,
|
|
|
|
const substitute_internal::Arg& a0,
|
|
|
|
const substitute_internal::Arg& a1,
|
|
|
|
const substitute_internal::Arg& a2,
|
|
|
|
const substitute_internal::Arg& a3,
|
|
|
|
const substitute_internal::Arg& a4,
|
|
|
|
const substitute_internal::Arg& a5) {
|
|
|
|
const absl::string_view args[] = {a0.piece(), a1.piece(), a2.piece(),
|
|
|
|
a3.piece(), a4.piece(), a5.piece()};
|
|
|
|
substitute_internal::SubstituteAndAppendArray(output, format, args,
|
|
|
|
ABSL_ARRAYSIZE(args));
|
|
|
|
}
|
|
|
|
|
|
|
|
inline void SubstituteAndAppend(std::string* output, absl::string_view format,
|
|
|
|
const substitute_internal::Arg& a0,
|
|
|
|
const substitute_internal::Arg& a1,
|
|
|
|
const substitute_internal::Arg& a2,
|
|
|
|
const substitute_internal::Arg& a3,
|
|
|
|
const substitute_internal::Arg& a4,
|
|
|
|
const substitute_internal::Arg& a5,
|
|
|
|
const substitute_internal::Arg& a6) {
|
|
|
|
const absl::string_view args[] = {a0.piece(), a1.piece(), a2.piece(),
|
|
|
|
a3.piece(), a4.piece(), a5.piece(),
|
|
|
|
a6.piece()};
|
|
|
|
substitute_internal::SubstituteAndAppendArray(output, format, args,
|
|
|
|
ABSL_ARRAYSIZE(args));
|
|
|
|
}
|
|
|
|
|
|
|
|
inline void SubstituteAndAppend(
|
|
|
|
std::string* output, absl::string_view format,
|
|
|
|
const substitute_internal::Arg& a0, const substitute_internal::Arg& a1,
|
|
|
|
const substitute_internal::Arg& a2, const substitute_internal::Arg& a3,
|
|
|
|
const substitute_internal::Arg& a4, const substitute_internal::Arg& a5,
|
|
|
|
const substitute_internal::Arg& a6, const substitute_internal::Arg& a7) {
|
|
|
|
const absl::string_view args[] = {a0.piece(), a1.piece(), a2.piece(),
|
|
|
|
a3.piece(), a4.piece(), a5.piece(),
|
|
|
|
a6.piece(), a7.piece()};
|
|
|
|
substitute_internal::SubstituteAndAppendArray(output, format, args,
|
|
|
|
ABSL_ARRAYSIZE(args));
|
|
|
|
}
|
|
|
|
|
|
|
|
inline void SubstituteAndAppend(
|
|
|
|
std::string* output, absl::string_view format,
|
|
|
|
const substitute_internal::Arg& a0, const substitute_internal::Arg& a1,
|
|
|
|
const substitute_internal::Arg& a2, const substitute_internal::Arg& a3,
|
|
|
|
const substitute_internal::Arg& a4, const substitute_internal::Arg& a5,
|
|
|
|
const substitute_internal::Arg& a6, const substitute_internal::Arg& a7,
|
|
|
|
const substitute_internal::Arg& a8) {
|
|
|
|
const absl::string_view args[] = {a0.piece(), a1.piece(), a2.piece(),
|
|
|
|
a3.piece(), a4.piece(), a5.piece(),
|
|
|
|
a6.piece(), a7.piece(), a8.piece()};
|
|
|
|
substitute_internal::SubstituteAndAppendArray(output, format, args,
|
|
|
|
ABSL_ARRAYSIZE(args));
|
|
|
|
}
|
|
|
|
|
|
|
|
inline void SubstituteAndAppend(
|
|
|
|
std::string* output, absl::string_view format,
|
|
|
|
const substitute_internal::Arg& a0, const substitute_internal::Arg& a1,
|
|
|
|
const substitute_internal::Arg& a2, const substitute_internal::Arg& a3,
|
|
|
|
const substitute_internal::Arg& a4, const substitute_internal::Arg& a5,
|
|
|
|
const substitute_internal::Arg& a6, const substitute_internal::Arg& a7,
|
|
|
|
const substitute_internal::Arg& a8, const substitute_internal::Arg& a9) {
|
|
|
|
const absl::string_view args[] = {
|
|
|
|
a0.piece(), a1.piece(), a2.piece(), a3.piece(), a4.piece(),
|
|
|
|
a5.piece(), a6.piece(), a7.piece(), a8.piece(), a9.piece()};
|
|
|
|
substitute_internal::SubstituteAndAppendArray(output, format, args,
|
|
|
|
ABSL_ARRAYSIZE(args));
|
|
|
|
}
|
|
|
|
|
|
|
|
#if defined(ABSL_BAD_CALL_IF)
|
|
|
|
// This body of functions catches cases where the number of placeholders
|
|
|
|
// doesn't match the number of data arguments.
|
|
|
|
void SubstituteAndAppend(std::string* output, const char* format)
|
|
|
|
ABSL_BAD_CALL_IF(
|
|
|
|
substitute_internal::PlaceholderBitmask(format) != 0,
|
|
|
|
"There were no substitution arguments "
|
|
|
|
"but this format string either has a $[0-9] in it or contains "
|
|
|
|
"an unescaped $ character (use $$ instead)");
|
|
|
|
|
|
|
|
void SubstituteAndAppend(std::string* output, const char* format,
|
|
|
|
const substitute_internal::Arg& a0)
|
|
|
|
ABSL_BAD_CALL_IF(substitute_internal::PlaceholderBitmask(format) != 1,
|
|
|
|
"There was 1 substitution argument given, but "
|
|
|
|
"this format string is missing its $0, contains "
|
|
|
|
"one of $1-$9, or contains an unescaped $ character (use "
|
|
|
|
"$$ instead)");
|
|
|
|
|
|
|
|
void SubstituteAndAppend(std::string* output, const char* format,
|
|
|
|
const substitute_internal::Arg& a0,
|
|
|
|
const substitute_internal::Arg& a1)
|
|
|
|
ABSL_BAD_CALL_IF(
|
|
|
|
substitute_internal::PlaceholderBitmask(format) != 3,
|
|
|
|
"There were 2 substitution arguments given, but this format string is "
|
|
|
|
"missing its $0/$1, contains one of $2-$9, or contains an "
|
|
|
|
"unescaped $ character (use $$ instead)");
|
|
|
|
|
|
|
|
void SubstituteAndAppend(std::string* output, const char* format,
|
|
|
|
const substitute_internal::Arg& a0,
|
|
|
|
const substitute_internal::Arg& a1,
|
|
|
|
const substitute_internal::Arg& a2)
|
|
|
|
ABSL_BAD_CALL_IF(
|
|
|
|
substitute_internal::PlaceholderBitmask(format) != 7,
|
|
|
|
"There were 3 substitution arguments given, but "
|
|
|
|
"this format string is missing its $0/$1/$2, contains one of "
|
|
|
|
"$3-$9, or contains an unescaped $ character (use $$ instead)");
|
|
|
|
|
|
|
|
void SubstituteAndAppend(std::string* output, const char* format,
|
|
|
|
const substitute_internal::Arg& a0,
|
|
|
|
const substitute_internal::Arg& a1,
|
|
|
|
const substitute_internal::Arg& a2,
|
|
|
|
const substitute_internal::Arg& a3)
|
|
|
|
ABSL_BAD_CALL_IF(
|
|
|
|
substitute_internal::PlaceholderBitmask(format) != 15,
|
|
|
|
"There were 4 substitution arguments given, but "
|
|
|
|
"this format string is missing its $0-$3, contains one of "
|
|
|
|
"$4-$9, or contains an unescaped $ character (use $$ instead)");
|
|
|
|
|
|
|
|
void SubstituteAndAppend(std::string* output, const char* format,
|
|
|
|
const substitute_internal::Arg& a0,
|
|
|
|
const substitute_internal::Arg& a1,
|
|
|
|
const substitute_internal::Arg& a2,
|
|
|
|
const substitute_internal::Arg& a3,
|
|
|
|
const substitute_internal::Arg& a4)
|
|
|
|
ABSL_BAD_CALL_IF(
|
|
|
|
substitute_internal::PlaceholderBitmask(format) != 31,
|
|
|
|
"There were 5 substitution arguments given, but "
|
|
|
|
"this format string is missing its $0-$4, contains one of "
|
|
|
|
"$5-$9, or contains an unescaped $ character (use $$ instead)");
|
|
|
|
|
|
|
|
void SubstituteAndAppend(std::string* output, const char* format,
|
|
|
|
const substitute_internal::Arg& a0,
|
|
|
|
const substitute_internal::Arg& a1,
|
|
|
|
const substitute_internal::Arg& a2,
|
|
|
|
const substitute_internal::Arg& a3,
|
|
|
|
const substitute_internal::Arg& a4,
|
|
|
|
const substitute_internal::Arg& a5)
|
|
|
|
ABSL_BAD_CALL_IF(
|
|
|
|
substitute_internal::PlaceholderBitmask(format) != 63,
|
|
|
|
"There were 6 substitution arguments given, but "
|
|
|
|
"this format string is missing its $0-$5, contains one of "
|
|
|
|
"$6-$9, or contains an unescaped $ character (use $$ instead)");
|
|
|
|
|
|
|
|
void SubstituteAndAppend(
|
|
|
|
std::string* output, const char* format, const substitute_internal::Arg& a0,
|
|
|
|
const substitute_internal::Arg& a1, const substitute_internal::Arg& a2,
|
|
|
|
const substitute_internal::Arg& a3, const substitute_internal::Arg& a4,
|
|
|
|
const substitute_internal::Arg& a5, const substitute_internal::Arg& a6)
|
|
|
|
ABSL_BAD_CALL_IF(
|
|
|
|
substitute_internal::PlaceholderBitmask(format) != 127,
|
|
|
|
"There were 7 substitution arguments given, but "
|
|
|
|
"this format string is missing its $0-$6, contains one of "
|
|
|
|
"$7-$9, or contains an unescaped $ character (use $$ instead)");
|
|
|
|
|
|
|
|
void SubstituteAndAppend(
|
|
|
|
std::string* output, const char* format, const substitute_internal::Arg& a0,
|
|
|
|
const substitute_internal::Arg& a1, const substitute_internal::Arg& a2,
|
|
|
|
const substitute_internal::Arg& a3, const substitute_internal::Arg& a4,
|
|
|
|
const substitute_internal::Arg& a5, const substitute_internal::Arg& a6,
|
|
|
|
const substitute_internal::Arg& a7)
|
|
|
|
ABSL_BAD_CALL_IF(
|
|
|
|
substitute_internal::PlaceholderBitmask(format) != 255,
|
|
|
|
"There were 8 substitution arguments given, but "
|
|
|
|
"this format string is missing its $0-$7, contains one of "
|
|
|
|
"$8-$9, or contains an unescaped $ character (use $$ instead)");
|
|
|
|
|
|
|
|
void SubstituteAndAppend(
|
|
|
|
std::string* output, const char* format, const substitute_internal::Arg& a0,
|
|
|
|
const substitute_internal::Arg& a1, const substitute_internal::Arg& a2,
|
|
|
|
const substitute_internal::Arg& a3, const substitute_internal::Arg& a4,
|
|
|
|
const substitute_internal::Arg& a5, const substitute_internal::Arg& a6,
|
|
|
|
const substitute_internal::Arg& a7, const substitute_internal::Arg& a8)
|
|
|
|
ABSL_BAD_CALL_IF(
|
|
|
|
substitute_internal::PlaceholderBitmask(format) != 511,
|
|
|
|
"There were 9 substitution arguments given, but "
|
|
|
|
"this format string is missing its $0-$8, contains a $9, or "
|
|
|
|
"contains an unescaped $ character (use $$ instead)");
|
|
|
|
|
|
|
|
void SubstituteAndAppend(
|
|
|
|
std::string* output, const char* format, const substitute_internal::Arg& a0,
|
|
|
|
const substitute_internal::Arg& a1, const substitute_internal::Arg& a2,
|
|
|
|
const substitute_internal::Arg& a3, const substitute_internal::Arg& a4,
|
|
|
|
const substitute_internal::Arg& a5, const substitute_internal::Arg& a6,
|
|
|
|
const substitute_internal::Arg& a7, const substitute_internal::Arg& a8,
|
|
|
|
const substitute_internal::Arg& a9)
|
|
|
|
ABSL_BAD_CALL_IF(
|
|
|
|
substitute_internal::PlaceholderBitmask(format) != 1023,
|
|
|
|
"There were 10 substitution arguments given, but this "
|
|
|
|
"format string either doesn't contain all of $0 through $9 or "
|
|
|
|
"contains an unescaped $ character (use $$ instead)");
|
|
|
|
#endif // ABSL_BAD_CALL_IF
|
|
|
|
|
|
|
|
// Substitute()
|
|
|
|
//
|
|
|
|
// Substitutes variables into a given format string. See file comments above
|
|
|
|
// for usage.
|
|
|
|
//
|
|
|
|
// The declarations of `Substitute()` below consist of overloads for passing 0
|
|
|
|
// to 10 arguments, respectively.
|
|
|
|
//
|
|
|
|
// NOTE: A zero-argument `Substitute()` may be used within variadic templates to
|
|
|
|
// allow a variable number of arguments.
|
|
|
|
//
|
|
|
|
// Example:
|
|
|
|
// template <typename... Args>
|
|
|
|
// void VarMsg(absl::string_view format, const Args&... args) {
|
|
|
|
// std::string s = absl::Substitute(format, args...);
|
|
|
|
|
|
|
|
ABSL_MUST_USE_RESULT inline std::string Substitute(absl::string_view format) {
|
|
|
|
std::string result;
|
|
|
|
SubstituteAndAppend(&result, format);
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
ABSL_MUST_USE_RESULT inline std::string Substitute(
|
|
|
|
absl::string_view format, const substitute_internal::Arg& a0) {
|
|
|
|
std::string result;
|
|
|
|
SubstituteAndAppend(&result, format, a0);
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
ABSL_MUST_USE_RESULT inline std::string Substitute(
|
|
|
|
absl::string_view format, const substitute_internal::Arg& a0,
|
|
|
|
const substitute_internal::Arg& a1) {
|
|
|
|
std::string result;
|
|
|
|
SubstituteAndAppend(&result, format, a0, a1);
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
ABSL_MUST_USE_RESULT inline std::string Substitute(
|
|
|
|
absl::string_view format, const substitute_internal::Arg& a0,
|
|
|
|
const substitute_internal::Arg& a1, const substitute_internal::Arg& a2) {
|
|
|
|
std::string result;
|
|
|
|
SubstituteAndAppend(&result, format, a0, a1, a2);
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
ABSL_MUST_USE_RESULT inline std::string Substitute(
|
|
|
|
absl::string_view format, const substitute_internal::Arg& a0,
|
|
|
|
const substitute_internal::Arg& a1, const substitute_internal::Arg& a2,
|
|
|
|
const substitute_internal::Arg& a3) {
|
|
|
|
std::string result;
|
|
|
|
SubstituteAndAppend(&result, format, a0, a1, a2, a3);
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
ABSL_MUST_USE_RESULT inline std::string Substitute(
|
|
|
|
absl::string_view format, const substitute_internal::Arg& a0,
|
|
|
|
const substitute_internal::Arg& a1, const substitute_internal::Arg& a2,
|
|
|
|
const substitute_internal::Arg& a3, const substitute_internal::Arg& a4) {
|
|
|
|
std::string result;
|
|
|
|
SubstituteAndAppend(&result, format, a0, a1, a2, a3, a4);
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
ABSL_MUST_USE_RESULT inline std::string Substitute(
|
|
|
|
absl::string_view format, const substitute_internal::Arg& a0,
|
|
|
|
const substitute_internal::Arg& a1, const substitute_internal::Arg& a2,
|
|
|
|
const substitute_internal::Arg& a3, const substitute_internal::Arg& a4,
|
|
|
|
const substitute_internal::Arg& a5) {
|
|
|
|
std::string result;
|
|
|
|
SubstituteAndAppend(&result, format, a0, a1, a2, a3, a4, a5);
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
ABSL_MUST_USE_RESULT inline std::string Substitute(
|
|
|
|
absl::string_view format, const substitute_internal::Arg& a0,
|
|
|
|
const substitute_internal::Arg& a1, const substitute_internal::Arg& a2,
|
|
|
|
const substitute_internal::Arg& a3, const substitute_internal::Arg& a4,
|
|
|
|
const substitute_internal::Arg& a5, const substitute_internal::Arg& a6) {
|
|
|
|
std::string result;
|
|
|
|
SubstituteAndAppend(&result, format, a0, a1, a2, a3, a4, a5, a6);
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
ABSL_MUST_USE_RESULT inline std::string Substitute(
|
|
|
|
absl::string_view format, const substitute_internal::Arg& a0,
|
|
|
|
const substitute_internal::Arg& a1, const substitute_internal::Arg& a2,
|
|
|
|
const substitute_internal::Arg& a3, const substitute_internal::Arg& a4,
|
|
|
|
const substitute_internal::Arg& a5, const substitute_internal::Arg& a6,
|
|
|
|
const substitute_internal::Arg& a7) {
|
|
|
|
std::string result;
|
|
|
|
SubstituteAndAppend(&result, format, a0, a1, a2, a3, a4, a5, a6, a7);
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
ABSL_MUST_USE_RESULT inline std::string Substitute(
|
|
|
|
absl::string_view format, const substitute_internal::Arg& a0,
|
|
|
|
const substitute_internal::Arg& a1, const substitute_internal::Arg& a2,
|
|
|
|
const substitute_internal::Arg& a3, const substitute_internal::Arg& a4,
|
|
|
|
const substitute_internal::Arg& a5, const substitute_internal::Arg& a6,
|
|
|
|
const substitute_internal::Arg& a7, const substitute_internal::Arg& a8) {
|
|
|
|
std::string result;
|
|
|
|
SubstituteAndAppend(&result, format, a0, a1, a2, a3, a4, a5, a6, a7, a8);
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
ABSL_MUST_USE_RESULT inline std::string Substitute(
|
|
|
|
absl::string_view format, const substitute_internal::Arg& a0,
|
|
|
|
const substitute_internal::Arg& a1, const substitute_internal::Arg& a2,
|
|
|
|
const substitute_internal::Arg& a3, const substitute_internal::Arg& a4,
|
|
|
|
const substitute_internal::Arg& a5, const substitute_internal::Arg& a6,
|
|
|
|
const substitute_internal::Arg& a7, const substitute_internal::Arg& a8,
|
|
|
|
const substitute_internal::Arg& a9) {
|
|
|
|
std::string result;
|
|
|
|
SubstituteAndAppend(&result, format, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
#if defined(ABSL_BAD_CALL_IF)
|
|
|
|
// This body of functions catches cases where the number of placeholders
|
|
|
|
// doesn't match the number of data arguments.
|
|
|
|
std::string Substitute(const char* format)
|
|
|
|
ABSL_BAD_CALL_IF(substitute_internal::PlaceholderBitmask(format) != 0,
|
|
|
|
"There were no substitution arguments "
|
|
|
|
"but this format string either has a $[0-9] in it or "
|
|
|
|
"contains an unescaped $ character (use $$ instead)");
|
|
|
|
|
|
|
|
std::string Substitute(const char* format, const substitute_internal::Arg& a0)
|
|
|
|
ABSL_BAD_CALL_IF(
|
|
|
|
substitute_internal::PlaceholderBitmask(format) != 1,
|
|
|
|
"There was 1 substitution argument given, but "
|
|
|
|
"this format string is missing its $0, contains one of $1-$9, "
|
|
|
|
"or contains an unescaped $ character (use $$ instead)");
|
|
|
|
|
|
|
|
std::string Substitute(const char* format, const substitute_internal::Arg& a0,
|
|
|
|
const substitute_internal::Arg& a1)
|
|
|
|
ABSL_BAD_CALL_IF(
|
|
|
|
substitute_internal::PlaceholderBitmask(format) != 3,
|
|
|
|
"There were 2 substitution arguments given, but "
|
|
|
|
"this format string is missing its $0/$1, contains one of "
|
|
|
|
"$2-$9, or contains an unescaped $ character (use $$ instead)");
|
|
|
|
|
|
|
|
std::string Substitute(const char* format, const substitute_internal::Arg& a0,
|
|
|
|
const substitute_internal::Arg& a1,
|
|
|
|
const substitute_internal::Arg& a2)
|
|
|
|
ABSL_BAD_CALL_IF(
|
|
|
|
substitute_internal::PlaceholderBitmask(format) != 7,
|
|
|
|
"There were 3 substitution arguments given, but "
|
|
|
|
"this format string is missing its $0/$1/$2, contains one of "
|
|
|
|
"$3-$9, or contains an unescaped $ character (use $$ instead)");
|
|
|
|
|
|
|
|
std::string Substitute(const char* format, const substitute_internal::Arg& a0,
|
|
|
|
const substitute_internal::Arg& a1,
|
|
|
|
const substitute_internal::Arg& a2,
|
|
|
|
const substitute_internal::Arg& a3)
|
|
|
|
ABSL_BAD_CALL_IF(
|
|
|
|
substitute_internal::PlaceholderBitmask(format) != 15,
|
|
|
|
"There were 4 substitution arguments given, but "
|
|
|
|
"this format string is missing its $0-$3, contains one of "
|
|
|
|
"$4-$9, or contains an unescaped $ character (use $$ instead)");
|
|
|
|
|
|
|
|
std::string Substitute(const char* format, const substitute_internal::Arg& a0,
|
|
|
|
const substitute_internal::Arg& a1,
|
|
|
|
const substitute_internal::Arg& a2,
|
|
|
|
const substitute_internal::Arg& a3,
|
|
|
|
const substitute_internal::Arg& a4)
|
|
|
|
ABSL_BAD_CALL_IF(
|
|
|
|
substitute_internal::PlaceholderBitmask(format) != 31,
|
|
|
|
"There were 5 substitution arguments given, but "
|
|
|
|
"this format string is missing its $0-$4, contains one of "
|
|
|
|
"$5-$9, or contains an unescaped $ character (use $$ instead)");
|
|
|
|
|
|
|
|
std::string Substitute(const char* format, const substitute_internal::Arg& a0,
|
|
|
|
const substitute_internal::Arg& a1,
|
|
|
|
const substitute_internal::Arg& a2,
|
|
|
|
const substitute_internal::Arg& a3,
|
|
|
|
const substitute_internal::Arg& a4,
|
|
|
|
const substitute_internal::Arg& a5)
|
|
|
|
ABSL_BAD_CALL_IF(
|
|
|
|
substitute_internal::PlaceholderBitmask(format) != 63,
|
|
|
|
"There were 6 substitution arguments given, but "
|
|
|
|
"this format string is missing its $0-$5, contains one of "
|
|
|
|
"$6-$9, or contains an unescaped $ character (use $$ instead)");
|
|
|
|
|
|
|
|
std::string Substitute(const char* format, const substitute_internal::Arg& a0,
|
|
|
|
const substitute_internal::Arg& a1,
|
|
|
|
const substitute_internal::Arg& a2,
|
|
|
|
const substitute_internal::Arg& a3,
|
|
|
|
const substitute_internal::Arg& a4,
|
|
|
|
const substitute_internal::Arg& a5,
|
|
|
|
const substitute_internal::Arg& a6)
|
|
|
|
ABSL_BAD_CALL_IF(
|
|
|
|
substitute_internal::PlaceholderBitmask(format) != 127,
|
|
|
|
"There were 7 substitution arguments given, but "
|
|
|
|
"this format string is missing its $0-$6, contains one of "
|
|
|
|
"$7-$9, or contains an unescaped $ character (use $$ instead)");
|
|
|
|
|
|
|
|
std::string Substitute(const char* format, const substitute_internal::Arg& a0,
|
|
|
|
const substitute_internal::Arg& a1,
|
|
|
|
const substitute_internal::Arg& a2,
|
|
|
|
const substitute_internal::Arg& a3,
|
|
|
|
const substitute_internal::Arg& a4,
|
|
|
|
const substitute_internal::Arg& a5,
|
|
|
|
const substitute_internal::Arg& a6,
|
|
|
|
const substitute_internal::Arg& a7)
|
|
|
|
ABSL_BAD_CALL_IF(
|
|
|
|
substitute_internal::PlaceholderBitmask(format) != 255,
|
|
|
|
"There were 8 substitution arguments given, but "
|
|
|
|
"this format string is missing its $0-$7, contains one of "
|
|
|
|
"$8-$9, or contains an unescaped $ character (use $$ instead)");
|
|
|
|
|
|
|
|
std::string Substitute(
|
|
|
|
const char* format, const substitute_internal::Arg& a0,
|
|
|
|
const substitute_internal::Arg& a1, const substitute_internal::Arg& a2,
|
|
|
|
const substitute_internal::Arg& a3, const substitute_internal::Arg& a4,
|
|
|
|
const substitute_internal::Arg& a5, const substitute_internal::Arg& a6,
|
|
|
|
const substitute_internal::Arg& a7, const substitute_internal::Arg& a8)
|
|
|
|
ABSL_BAD_CALL_IF(
|
|
|
|
substitute_internal::PlaceholderBitmask(format) != 511,
|
|
|
|
"There were 9 substitution arguments given, but "
|
|
|
|
"this format string is missing its $0-$8, contains a $9, or "
|
|
|
|
"contains an unescaped $ character (use $$ instead)");
|
|
|
|
|
|
|
|
std::string Substitute(
|
|
|
|
const char* format, const substitute_internal::Arg& a0,
|
|
|
|
const substitute_internal::Arg& a1, const substitute_internal::Arg& a2,
|
|
|
|
const substitute_internal::Arg& a3, const substitute_internal::Arg& a4,
|
|
|
|
const substitute_internal::Arg& a5, const substitute_internal::Arg& a6,
|
|
|
|
const substitute_internal::Arg& a7, const substitute_internal::Arg& a8,
|
|
|
|
const substitute_internal::Arg& a9)
|
|
|
|
ABSL_BAD_CALL_IF(
|
|
|
|
substitute_internal::PlaceholderBitmask(format) != 1023,
|
|
|
|
"There were 10 substitution arguments given, but this "
|
|
|
|
"format string either doesn't contain all of $0 through $9 or "
|
|
|
|
"contains an unescaped $ character (use $$ instead)");
|
|
|
|
#endif // ABSL_BAD_CALL_IF
|
|
|
|
|
|
|
|
ABSL_NAMESPACE_END
|
|
|
|
} // namespace absl
|
|
|
|
|
|
|
|
#endif // ABSL_STRINGS_SUBSTITUTE_H_
|