diff options
Diffstat (limited to 'contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_cat.cc')
| -rw-r--r-- | contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_cat.cc | 172 |
1 files changed, 151 insertions, 21 deletions
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_cat.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_cat.cc index 36ebfbeb1f..2f74723a54 100644 --- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_cat.cc +++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_cat.cc @@ -16,13 +16,15 @@ #include <assert.h> -#include <algorithm> #include <cstddef> #include <cstdint> #include <cstring> +#include <initializer_list> #include <util/generic/string.h> +#include <type_traits> -#include "y_absl/strings/ascii.h" +#include "y_absl/base/config.h" +#include "y_absl/base/nullability.h" #include "y_absl/strings/internal/resize_uninitialized.h" #include "y_absl/strings/numbers.h" #include "y_absl/strings/string_view.h" @@ -30,6 +32,7 @@ namespace y_absl { Y_ABSL_NAMESPACE_BEGIN + // ---------------------------------------------------------------------- // StrCat() // This merges the given strings or integers, with no delimiter. This @@ -37,9 +40,10 @@ Y_ABSL_NAMESPACE_BEGIN // of a mix of raw C strings, string_views, strings, and integer values. // ---------------------------------------------------------------------- +namespace { // Append is merely a version of memcpy that returns the address of the byte // after the area just overwritten. -static char* Append(char* out, const AlphaNum& x) { +y_absl::Nonnull<char*> Append(y_absl::Nonnull<char*> out, const AlphaNum& x) { // memcpy is allowed to overwrite arbitrary memory, so doing this after the // call would force an extra fetch of x.size(). char* after = out + x.size(); @@ -49,6 +53,8 @@ static char* Append(char* out, const AlphaNum& x) { return after; } +} // namespace + TString StrCat(const AlphaNum& a, const AlphaNum& b) { TString result; y_absl::strings_internal::STLStringResizeUninitialized(&result, @@ -92,6 +98,130 @@ TString StrCat(const AlphaNum& a, const AlphaNum& b, const AlphaNum& c, namespace strings_internal { // Do not call directly - these are not part of the public API. +void STLStringAppendUninitializedAmortized(TString* dest, + size_t to_append) { + strings_internal::AppendUninitializedTraits<TString>::Append(dest, + to_append); +} + +template <typename Integer> +std::enable_if_t<std::is_integral<Integer>::value, TString> IntegerToString( + Integer i) { + TString str; + const auto /* either bool or std::false_type */ is_negative = + y_absl::numbers_internal::IsNegative(i); + const uint32_t digits = y_absl::numbers_internal::Base10Digits( + y_absl::numbers_internal::UnsignedAbsoluteValue(i)); + y_absl::strings_internal::STLStringResizeUninitialized( + &str, digits + static_cast<uint32_t>(is_negative)); + y_absl::numbers_internal::FastIntToBufferBackward(i, &str[str.size()], digits); + return str; +} + +template <> +TString IntegerToString(long i) { // NOLINT + if (sizeof(i) <= sizeof(int)) { + return IntegerToString(static_cast<int>(i)); + } else { + return IntegerToString(static_cast<long long>(i)); // NOLINT + } +} + +template <> +TString IntegerToString(unsigned long i) { // NOLINT + if (sizeof(i) <= sizeof(unsigned int)) { + return IntegerToString(static_cast<unsigned int>(i)); + } else { + return IntegerToString(static_cast<unsigned long long>(i)); // NOLINT + } +} + +template <typename Float> +std::enable_if_t<std::is_floating_point<Float>::value, TString> +FloatToString(Float f) { + TString result; + strings_internal::STLStringResizeUninitialized( + &result, numbers_internal::kSixDigitsToBufferSize); + char* start = &result[0]; + result.erase(numbers_internal::SixDigitsToBuffer(f, start)); + return result; +} + +TString SingleArgStrCat(int x) { return IntegerToString(x); } +TString SingleArgStrCat(unsigned int x) { return IntegerToString(x); } +// NOLINTNEXTLINE +TString SingleArgStrCat(long x) { return IntegerToString(x); } +// NOLINTNEXTLINE +TString SingleArgStrCat(unsigned long x) { return IntegerToString(x); } +// NOLINTNEXTLINE +TString SingleArgStrCat(long long x) { return IntegerToString(x); } +// NOLINTNEXTLINE +TString SingleArgStrCat(unsigned long long x) { return IntegerToString(x); } +TString SingleArgStrCat(float x) { return FloatToString(x); } +TString SingleArgStrCat(double x) { return FloatToString(x); } + +template <class Integer> +std::enable_if_t<std::is_integral<Integer>::value, void> AppendIntegerToString( + TString& str, Integer i) { + const auto /* either bool or std::false_type */ is_negative = + y_absl::numbers_internal::IsNegative(i); + const uint32_t digits = y_absl::numbers_internal::Base10Digits( + y_absl::numbers_internal::UnsignedAbsoluteValue(i)); + y_absl::strings_internal::STLStringAppendUninitializedAmortized( + &str, digits + static_cast<uint32_t>(is_negative)); + y_absl::numbers_internal::FastIntToBufferBackward(i, &str[str.size()], digits); +} + +template <> +void AppendIntegerToString(TString& str, long i) { // NOLINT + if (sizeof(i) <= sizeof(int)) { + return AppendIntegerToString(str, static_cast<int>(i)); + } else { + return AppendIntegerToString(str, static_cast<long long>(i)); // NOLINT + } +} + +template <> +void AppendIntegerToString(TString& str, + unsigned long i) { // NOLINT + if (sizeof(i) <= sizeof(unsigned int)) { + return AppendIntegerToString(str, static_cast<unsigned int>(i)); + } else { + return AppendIntegerToString(str, + static_cast<unsigned long long>(i)); // NOLINT + } +} + +// `SingleArgStrAppend` overloads are defined here for the same reasons as with +// `SingleArgStrCat` above. +void SingleArgStrAppend(TString& str, int x) { + return AppendIntegerToString(str, x); +} + +void SingleArgStrAppend(TString& str, unsigned int x) { + return AppendIntegerToString(str, x); +} + +// NOLINTNEXTLINE +void SingleArgStrAppend(TString& str, long x) { + return AppendIntegerToString(str, x); +} + +// NOLINTNEXTLINE +void SingleArgStrAppend(TString& str, unsigned long x) { + return AppendIntegerToString(str, x); +} + +// NOLINTNEXTLINE +void SingleArgStrAppend(TString& str, long long x) { + return AppendIntegerToString(str, x); +} + +// NOLINTNEXTLINE +void SingleArgStrAppend(TString& str, unsigned long long x) { + return AppendIntegerToString(str, x); +} + TString CatPieces(std::initializer_list<y_absl::string_view> pieces) { TString result; size_t total_size = 0; @@ -120,15 +250,15 @@ TString CatPieces(std::initializer_list<y_absl::string_view> pieces) { assert(((src).size() == 0) || \ (uintptr_t((src).data() - (dest).data()) > uintptr_t((dest).size()))) -void AppendPieces(TString* dest, +void AppendPieces(y_absl::Nonnull<TString*> dest, std::initializer_list<y_absl::string_view> pieces) { size_t old_size = dest->size(); - size_t total_size = old_size; + size_t to_append = 0; for (y_absl::string_view piece : pieces) { ASSERT_NO_OVERLAP(*dest, piece); - total_size += piece.size(); + to_append += piece.size(); } - strings_internal::STLStringResizeUninitializedAmortized(dest, total_size); + strings_internal::STLStringAppendUninitializedAmortized(dest, to_append); char* const begin = &(*dest)[0]; char* out = begin + old_size; @@ -144,23 +274,23 @@ void AppendPieces(TString* dest, } // namespace strings_internal -void StrAppend(TString* dest, const AlphaNum& a) { +void StrAppend(y_absl::Nonnull<TString*> dest, const AlphaNum& a) { ASSERT_NO_OVERLAP(*dest, a); TString::size_type old_size = dest->size(); - strings_internal::STLStringResizeUninitializedAmortized(dest, - old_size + a.size()); + strings_internal::STLStringAppendUninitializedAmortized(dest, a.size()); char* const begin = &(*dest)[0]; char* out = begin + old_size; out = Append(out, a); assert(out == begin + dest->size()); } -void StrAppend(TString* dest, const AlphaNum& a, const AlphaNum& b) { +void StrAppend(y_absl::Nonnull<TString*> dest, const AlphaNum& a, + const AlphaNum& b) { ASSERT_NO_OVERLAP(*dest, a); ASSERT_NO_OVERLAP(*dest, b); TString::size_type old_size = dest->size(); - strings_internal::STLStringResizeUninitializedAmortized( - dest, old_size + a.size() + b.size()); + strings_internal::STLStringAppendUninitializedAmortized(dest, + a.size() + b.size()); char* const begin = &(*dest)[0]; char* out = begin + old_size; out = Append(out, a); @@ -168,14 +298,14 @@ void StrAppend(TString* dest, const AlphaNum& a, const AlphaNum& b) { assert(out == begin + dest->size()); } -void StrAppend(TString* dest, const AlphaNum& a, const AlphaNum& b, - const AlphaNum& c) { +void StrAppend(y_absl::Nonnull<TString*> dest, const AlphaNum& a, + const AlphaNum& b, const AlphaNum& c) { ASSERT_NO_OVERLAP(*dest, a); ASSERT_NO_OVERLAP(*dest, b); ASSERT_NO_OVERLAP(*dest, c); TString::size_type old_size = dest->size(); - strings_internal::STLStringResizeUninitializedAmortized( - dest, old_size + a.size() + b.size() + c.size()); + strings_internal::STLStringAppendUninitializedAmortized( + dest, a.size() + b.size() + c.size()); char* const begin = &(*dest)[0]; char* out = begin + old_size; out = Append(out, a); @@ -184,15 +314,15 @@ void StrAppend(TString* dest, const AlphaNum& a, const AlphaNum& b, assert(out == begin + dest->size()); } -void StrAppend(TString* dest, const AlphaNum& a, const AlphaNum& b, - const AlphaNum& c, const AlphaNum& d) { +void StrAppend(y_absl::Nonnull<TString*> dest, const AlphaNum& a, + const AlphaNum& b, const AlphaNum& c, const AlphaNum& d) { ASSERT_NO_OVERLAP(*dest, a); ASSERT_NO_OVERLAP(*dest, b); ASSERT_NO_OVERLAP(*dest, c); ASSERT_NO_OVERLAP(*dest, d); TString::size_type old_size = dest->size(); - strings_internal::STLStringResizeUninitializedAmortized( - dest, old_size + a.size() + b.size() + c.size() + d.size()); + strings_internal::STLStringAppendUninitializedAmortized( + dest, a.size() + b.size() + c.size() + d.size()); char* const begin = &(*dest)[0]; char* out = begin + old_size; out = Append(out, a); |