Merge StringWriter into StringBuffer

fmt/string.h

@@ -14,53 +14,25 @@
 
 namespace fmt {
 
-namespace internal {
-
-// A buffer that stores data in ``std::string``.
-template <typename Char>
-class StringBuffer : public basic_buffer<Char> {
- private:
-  std::basic_string<Char> data_;
-
- protected:
-  virtual void grow(std::size_t size) {
-    data_.resize(size);
-    this->ptr_ = &data_[0];
-    this->capacity_ = size;
-  }
-
- public:
-  // Moves the data to ``str`` clearing the buffer.
-  void move_to(std::basic_string<Char> &str) {
-    data_.resize(this->size_);
-    str.swap(data_);
-    this->capacity_ = this->size_ = 0;
-    this->ptr_ = 0;
-  }
-};
-}  // namespace internal
-
 /**
   \rst
-  This class template provides operations for formatting and writing data
-  into a character stream. The output is stored in ``std::string`` that grows
-  dynamically.
+  This class template represents a character buffer backed by std::string.
 
   You can use one of the following typedefs for common character types
   and the standard allocator:
 
-  +---------------+----------------------------+
-  | Type          | Definition                 |
-  +===============+============================+
-  | StringWriter  | BasicStringWriter<char>    |
-  +---------------+----------------------------+
-  | WStringWriter | BasicStringWriter<wchar_t> |
-  +---------------+----------------------------+
+  +----------------+------------------------------+
+  | Type           | Definition                   |
+  +================+==============================+
+  | string_buffer  | basic_string_buffer<char>    |
+  +----------------+------------------------------+
+  | wstring_buffer | basic_string_buffer<wchar_t> |
+  +----------------+------------------------------+
 
   **Example**::
 
-     StringWriter out;
-     out << "The answer is " << 42 << "\n";
+     string_buffer out;
+     format_to(out, "The answer is {}", 42);
 
   This will write the following output to the ``out`` object:
 
@@ -70,32 +42,34 @@ class StringBuffer : public basic_buffer<Char> {
 
   The output can be moved to an ``std::string`` with ``out.move_to()``.
   \endrst
- */
-template <typename Char>
-class BasicStringWriter : public basic_writer<Char> {
+ */template <typename Char>
+class basic_string_buffer : public basic_buffer<Char> {
  private:
-  internal::StringBuffer<Char> buffer_;
+  std::basic_string<Char> data_;
 
- public:
-  /**
-    \rst
-    Constructs a :class:`fmt::BasicStringWriter` object.
-    \endrst
-   */
-  BasicStringWriter() : basic_writer<Char>(buffer_) {}
+ protected:
+  virtual void grow(std::size_t size) {
+    data_.resize(size);
+    this->ptr_ = &data_[0];
+    this->capacity_ = size;
+  }
 
+ public:
   /**
     \rst
     Moves the buffer content to *str* clearing the buffer.
     \endrst
    */
   void move_to(std::basic_string<Char> &str) {
-    buffer_.move_to(str);
+    data_.resize(this->size_);
+    str.swap(data_);
+    this->capacity_ = this->size_ = 0;
+    this->ptr_ = 0;
   }
 };
 
-typedef BasicStringWriter<char> StringWriter;
-typedef BasicStringWriter<wchar_t> WStringWriter;
+typedef basic_string_buffer<char> string_buffer;
+typedef basic_string_buffer<wchar_t> wstring_buffer;
 
 /**
   \rst
@@ -110,9 +84,11 @@ typedef BasicStringWriter<wchar_t> WStringWriter;
  */
 template <typename T>
 std::string to_string(const T &value) {
-  fmt::MemoryWriter w;
-  w.write(value);
-  return w.str();
+  string_buffer buf;
+  basic_writer<char>(buf).write(value);
+  std::string str;
+  buf.move_to(str);
+  return str;
 }
 }
 

test/string-test.cc

@@ -10,10 +10,10 @@
 #include "fmt/string.h"
 #include "gtest/gtest.h"
 
-using fmt::internal::StringBuffer;
+using fmt::string_buffer;
 
 TEST(StringBufferTest, Empty) {
-  StringBuffer<char> buffer;
+  string_buffer buffer;
   EXPECT_EQ(0, buffer.size());
   EXPECT_EQ(0, buffer.capacity());
   std::string data;
@@ -25,7 +25,7 @@ TEST(StringBufferTest, Empty) {
 }
 
 TEST(StringBufferTest, Reserve) {
-  StringBuffer<char> buffer;
+  string_buffer buffer;
   std::size_t capacity = std::string().capacity() + 10;
   buffer.reserve(capacity);
   EXPECT_EQ(0, buffer.size());
@@ -36,7 +36,7 @@ TEST(StringBufferTest, Reserve) {
 }
 
 TEST(StringBufferTest, Resize) {
-  StringBuffer<char> buffer;
+  string_buffer buffer;
   std::size_t size = std::string().capacity() + 10;
   buffer.resize(size);
   EXPECT_EQ(size, buffer.size());
@@ -47,7 +47,7 @@ TEST(StringBufferTest, Resize) {
 }
 
 TEST(StringBufferTest, MoveTo) {
-  StringBuffer<char> buffer;
+  string_buffer buffer;
   std::size_t size = std::string().capacity() + 10;
   buffer.resize(size);
   const char *p = &buffer[0];
@@ -58,25 +58,12 @@ TEST(StringBufferTest, MoveTo) {
   EXPECT_EQ(0, buffer.capacity());
 }
 
-TEST(StringWriterTest, MoveTo) {
-  fmt::StringWriter out;
-  out.write("The answer is ");
-  out.write(42);
-  out.write("\n");
-  std::string s;
-  out.move_to(s);
-  EXPECT_EQ("The answer is 42\n", s);
-  EXPECT_EQ(0, out.size());
-}
-
-TEST(StringWriterTest, WString) {
-  fmt::WStringWriter out;
-  out.write("The answer is ");
-  out.write(42);
-  out.write("\n");
+TEST(StringBufferTest, WString) {
+  fmt::wstring_buffer out;
+  out.push_back(L'x');
   std::wstring s;
   out.move_to(s);
-  EXPECT_EQ(L"The answer is 42\n", s);
+  EXPECT_EQ(L"x", s);
 }
 
 TEST(StringTest, ToString) {