| /* |
| * Copyright 2018 The WebRTC Project Authors. All rights reserved. |
| * |
| * Use of this source code is governed by a BSD-style license |
| * that can be found in the LICENSE file in the root of the source |
| * tree. An additional intellectual property rights grant can be found |
| * in the file PATENTS. All contributing project authors may |
| * be found in the AUTHORS file in the root of the source tree. |
| */ |
| |
| #ifndef RTC_BASE_STRINGS_STRING_BUILDER_H_ |
| #define RTC_BASE_STRINGS_STRING_BUILDER_H_ |
| |
| #include <cstdio> |
| #include <string> |
| |
| #include "rtc_base/checks.h" |
| #include "rtc_base/stringutils.h" |
| |
| namespace rtc { |
| |
| // This is a minimalistic string builder class meant to cover the most cases |
| // of when you might otherwise be tempted to use a stringstream (discouraged |
| // for anything except logging). |
| // This class allocates a fixed size buffer on the stack and concatenates |
| // strings and numbers into it, allowing the results to be read via |str()|. |
| template <size_t buffer_size> |
| class SimpleStringBuilder { |
| public: |
| SimpleStringBuilder() { buffer_[0] = '\0'; } |
| SimpleStringBuilder(const SimpleStringBuilder&) = delete; |
| SimpleStringBuilder& operator=(const SimpleStringBuilder&) = delete; |
| |
| SimpleStringBuilder& operator<<(const char* str) { return Append(str); } |
| |
| SimpleStringBuilder& operator<<(char ch) { return Append(&ch, 1); } |
| |
| SimpleStringBuilder& operator<<(const std::string& str) { |
| return Append(str.c_str(), str.length()); |
| } |
| |
| // Numeric conversion routines. |
| // |
| // We use std::[v]snprintf instead of std::to_string because: |
| // * std::to_string relies on the current locale for formatting purposes, |
| // and therefore concurrent calls to std::to_string from multiple threads |
| // may result in partial serialization of calls |
| // * snprintf allows us to print the number directly into our buffer. |
| // * avoid allocating a std::string (potential heap alloc). |
| // TODO(tommi): Switch to std::to_chars in C++17. |
| |
| SimpleStringBuilder& operator<<(int i) { return AppendFormat("%d", i); } |
| |
| SimpleStringBuilder& operator<<(unsigned i) { return AppendFormat("%u", i); } |
| |
| SimpleStringBuilder& operator<<(long i) { // NOLINT |
| return AppendFormat("%ld", i); |
| } |
| |
| SimpleStringBuilder& operator<<(long long i) { // NOLINT |
| return AppendFormat("%lld", i); |
| } |
| |
| SimpleStringBuilder& operator<<(unsigned long i) { // NOLINT |
| return AppendFormat("%lu", i); |
| } |
| |
| SimpleStringBuilder& operator<<(unsigned long long i) { // NOLINT |
| return AppendFormat("%llu", i); |
| } |
| |
| SimpleStringBuilder& operator<<(float f) { return AppendFormat("%f", f); } |
| |
| SimpleStringBuilder& operator<<(double f) { return AppendFormat("%f", f); } |
| |
| SimpleStringBuilder& operator<<(long double f) { |
| return AppendFormat("%Lf", f); |
| } |
| |
| // Returns a pointer to the built string. The name |str()| is borrowed for |
| // compatibility reasons as we replace usage of stringstream throughout the |
| // code base. |
| const char* str() const { return &buffer_[0]; } |
| |
| // Returns the length of the string. The name |size()| is picked for STL |
| // compatibility reasons. |
| size_t size() const { return size_; } |
| |
| // Allows appending a printf style formatted string. |
| SimpleStringBuilder& AppendFormat(const char* fmt, ...) { |
| va_list args; |
| va_start(args, fmt); |
| int len = std::vsnprintf(&buffer_[size_], buffer_size - size_, fmt, args); |
| RTC_DCHECK_GE(len, 0); |
| // Negative values are likely programmer error, but let's not update the |
| // length if so. |
| if (len > 0) |
| AddToLength(len); |
| va_end(args); |
| return *this; |
| } |
| |
| // An alternate way from operator<<() to append a string. This variant is |
| // slightly more efficient when the length of the string to append, is known. |
| SimpleStringBuilder& Append(const char* str, size_t length = SIZE_UNKNOWN) { |
| AddToLength( |
| rtc::strcpyn(&buffer_[size_], buffer_size - size_, str, length)); |
| return *this; |
| } |
| |
| private: |
| void AddToLength(size_t chars_added) { |
| size_ += chars_added; |
| RTC_DCHECK_EQ('\0', buffer_[size_]); |
| RTC_DCHECK_LE(size_, buffer_size - 1) |
| << "Buffer size limit reached (" << buffer_size << ")"; |
| } |
| |
| // An always-zero-terminated fixed buffer that we write to. |
| // Assuming the SimpleStringBuilder instance lives on the stack, this |
| // buffer will be stack allocated, which is done for performance reasons. |
| // Having a fixed size is furthermore useful to avoid unnecessary resizing |
| // while building it. |
| char buffer_[buffer_size]; // NOLINT |
| |
| // Represents the number of characters written to the buffer. |
| // This does not include the terminating '\0'. |
| size_t size_ = 0; |
| }; |
| |
| } // namespace rtc |
| |
| #endif // RTC_BASE_STRINGS_STRING_BUILDER_H_ |