[Groonga-commit] groonga/grnxx at c42a121 [master] Update grnxx::StringBuilder.

Back to archive index

susumu.yata null+****@clear*****
Mon Jul 1 12:45:20 JST 2013


susumu.yata	2013-07-01 12:45:20 +0900 (Mon, 01 Jul 2013)

  New Revision: c42a12117b9d2b7fdf38f925d133c4b5b09f86d7
  https://github.com/groonga/grnxx/commit/c42a12117b9d2b7fdf38f925d133c4b5b09f86d7

  Message:
    Update grnxx::StringBuilder.

  Modified files:
    lib/grnxx/string_builder.cpp
    lib/grnxx/string_builder.hpp

  Modified: lib/grnxx/string_builder.cpp (+32 -24)
===================================================================
--- lib/grnxx/string_builder.cpp    2013-07-01 12:07:24 +0900 (1a8f922)
+++ lib/grnxx/string_builder.cpp    2013-07-01 12:45:20 +0900 (704391e)
@@ -19,6 +19,8 @@
 
 #include <cmath>
 #include <cstdio>
+#include <cstring>
+#include <new>
 #include <utility>
 
 #include "grnxx/exception.hpp"
@@ -128,13 +130,11 @@ StringBuilder &StringBuilder::append(const char *ptr, size_t length) {
   return *this;
 }
 
-// TODO: To be removed if this is not used.
 StringBuilder &StringBuilder::resize(size_t length) {
-  const size_t size_left = end_ - ptr_;
-  if (length > size_left) {
+  const size_t size = end_ - ptr_;
+  if (length > size) {
     if (!resize_buf(length + 1)) {
-      length = size_left;
-      failed_ = true;
+      return *this;
     }
   }
   ptr_ = begin_ + length;
@@ -142,6 +142,14 @@ StringBuilder &StringBuilder::resize(size_t length) {
   return *this;
 }
 
+void StringBuilder::clear() {
+  ptr_ = begin_;
+  if (ptr_) {
+    *ptr_ = '\0';
+  }
+  failed_ = false;
+}
+
 bool StringBuilder::auto_resize(size_t size) {
   if (~flags_ & STRING_BUILDER_AUTO_RESIZE) {
     failed_ = true;
@@ -162,14 +170,15 @@ bool StringBuilder::resize_buf(size_t size) {
       GRNXX_ERROR() << "new char [" << size << "] failed";
       throw MemoryError();
     }
+    failed_ = true;
     return false;
   }
   const size_t length = ptr_ - begin_;
   std::memcpy(new_buf.get(), begin_, length);
-  ptr_ = new_buf.get() + length;
-  begin_ = new_buf.get();
-  end_ = new_buf.get() + size - 1;
   buf_ = std::move(new_buf);
+  begin_ = buf_.get();
+  end_ = begin_ + size - 1;
+  ptr_ = begin_ + length;
   return true;
 }
 
@@ -177,7 +186,6 @@ StringBuilder &operator<<(StringBuilder &builder, long long value) {
   if (!builder) {
     return builder;
   }
-
   char buf[32];
   char *ptr = buf;
   char *left = ptr;
@@ -189,53 +197,42 @@ StringBuilder &operator<<(StringBuilder &builder, long long value) {
   } else {
     *ptr++ = '-';
     ++left;
-
     do {
       // C++11 always rounds the result toward 0.
       *ptr++ = static_cast<char>('0' - (value % 10));
       value /= 10;
     } while (value != 0);
   }
-
   char *right = ptr - 1;
   while (left < right) {
     using std::swap;
     swap(*left++, *right--);
   }
-
   return builder.append(buf, ptr - buf);
 }
 StringBuilder &operator<<(StringBuilder &builder, unsigned long long value) {
   if (!builder) {
     return builder;
   }
-
   char buf[32];
   char *ptr = buf;
   do {
     *ptr++ = static_cast<char>('0' + (value % 10));
     value /= 10;
   } while (value != 0);
-
   char *left = buf;
   char *right = ptr - 1;
   while (left < right) {
     using std::swap;
     swap(*left++, *right--);
   }
-
   return builder.append(buf, ptr - buf);
 }
 
-StringBuilder &operator<<(StringBuilder &builder, float value) {
-  return builder << static_cast<double>(value);
-}
-
 StringBuilder &operator<<(StringBuilder &builder, double value) {
   if (!builder) {
     return builder;
   }
-
   switch (std::fpclassify(value)) {
     case FP_NORMAL:
     case FP_SUBNORMAL:
@@ -243,7 +240,7 @@ StringBuilder &operator<<(StringBuilder &builder, double value) {
       break;
     }
     case FP_INFINITE: {
-      if (value > 0) {
+      if (value > 0.0) {
         return builder.append("inf", 3);
       } else {
         return builder.append("-inf", 4);
@@ -254,7 +251,6 @@ StringBuilder &operator<<(StringBuilder &builder, double value) {
       return builder.append("nan", 3);
     }
   }
-
   // The maximum value of double-precision floating point number (IEEE754)
   // is 1.797693134862316E+308.
   char buf[512];
@@ -268,6 +264,10 @@ StringBuilder &operator<<(StringBuilder &builder, double value) {
   return builder.append(buf, length);
 }
 
+StringBuilder &operator<<(StringBuilder &builder, bool value) {
+  return value ? builder.append("true", 4) : builder.append("false", 5);
+}
+
 StringBuilder &operator<<(StringBuilder &builder, const void *value) {
   if (!builder) {
     return builder;
@@ -275,11 +275,9 @@ StringBuilder &operator<<(StringBuilder &builder, const void *value) {
   if (!value) {
     return builder.append("nullptr", 7);
   }
-
   char buf[(sizeof(value) * 2) + 2];
   buf[0] = '0';
   buf[1] = 'x';
-
   uintptr_t address = reinterpret_cast<uintptr_t>(value);
   for (size_t i = 2; i < sizeof(buf); ++i) {
     const uintptr_t digit = address >> ((sizeof(value) * 8) - 4);
@@ -290,6 +288,16 @@ StringBuilder &operator<<(StringBuilder &builder, const void *value) {
   return builder.append(buf, sizeof(buf));
 }
 
+StringBuilder &operator<<(StringBuilder &builder, const char *value) {
+  if (!builder) {
+    return builder;
+  }
+  if (!value) {
+    return builder.append("nullptr", 7);
+  }
+  return builder.append(value, std::strlen(value));
+}
+
 StringBuilder &operator<<(StringBuilder &builder, const Bytes &bytes) {
   return builder.append(reinterpret_cast<const char *>(bytes.data()),
                         bytes.size());

  Modified: lib/grnxx/string_builder.hpp (+19 -41)
===================================================================
--- lib/grnxx/string_builder.hpp    2013-07-01 12:07:24 +0900 (cf46746)
+++ lib/grnxx/string_builder.hpp    2013-07-01 12:45:20 +0900 (43c0e1a)
@@ -20,7 +20,6 @@
 
 #include "grnxx/features.hpp"
 
-#include <cstring>
 #include <exception>
 #include <memory>
 
@@ -102,10 +101,13 @@ class StringBuilder {
   // Append a sequence of length characters.
   StringBuilder &append(const char *ptr, size_t length);
 
-  // TODO: To be removed if this is not used.
-  // Resize the internal buffer.
+  // Resize the string.
+  // Note that the contents of the extended part are undefined.
   StringBuilder &resize(size_t length);
 
+  // Move the pointer to the beginning and clear the failure flag.
+  void clear();
+
   // Return the "i"-th byte.
   const char &operator[](size_t i) const {
     return begin_[i];
@@ -119,7 +121,6 @@ class StringBuilder {
   Bytes bytes() const {
     return Bytes(begin_, ptr_ - begin_);
   }
-
   // Return the address of the string.
   const char *c_str() const {
     return begin_ ? begin_ : "";
@@ -129,17 +130,6 @@ class StringBuilder {
     return ptr_ - begin_;
   }
 
-  // TODO: To be removed if this is not used.
-  void swap(StringBuilder &rhs) {
-    using std::swap;
-    swap(buf_, rhs.buf_);
-    swap(begin_, rhs.begin_);
-    swap(end_, rhs.end_);
-    swap(ptr_, rhs.ptr_);
-    swap(flags_, rhs.flags_);
-    swap(failed_, rhs.failed_);
-  }
-
  private:
   std::unique_ptr<char[]> buf_;
   char *begin_;
@@ -157,17 +147,12 @@ class StringBuilder {
   StringBuilder &operator=(const StringBuilder &) = delete;
 };
 
-// TODO: To be removed if this is not used.
-inline void swap(StringBuilder &lhs, StringBuilder &rhs) {
-  lhs.swap(rhs);
-}
-
-// Characters.
+// Append a character.
 inline StringBuilder &operator<<(StringBuilder &builder, char value) {
   return builder.append(value);
 }
 
-// Signed integers.
+// Append a signed integer.
 StringBuilder &operator<<(StringBuilder &builder, long long value);
 
 inline StringBuilder &operator<<(StringBuilder &builder, signed char value) {
@@ -183,7 +168,7 @@ inline StringBuilder &operator<<(StringBuilder &builder, long value) {
   return builder << static_cast<long long>(value);
 }
 
-// Unsigned integers.
+// Append an unsigned integer.
 StringBuilder &operator<<(StringBuilder &builder, unsigned long long value);
 
 inline StringBuilder &operator<<(StringBuilder &builder, unsigned char value) {
@@ -199,33 +184,26 @@ inline StringBuilder &operator<<(StringBuilder &builder, unsigned long value) {
   return builder << static_cast<unsigned long long>(value);
 }
 
-// Floating point numbers.
-StringBuilder &operator<<(StringBuilder &builder, float value);
+// Append a floating point number.
 StringBuilder &operator<<(StringBuilder &builder, double value);
 
-// Boolean values (true/false).
-inline StringBuilder &operator<<(StringBuilder &builder, bool value) {
-  return value ? builder.append("true", 4) : builder.append("false", 5);
+inline StringBuilder &operator<<(StringBuilder &builder, float value) {
+  return builder << static_cast<double>(value);
 }
 
-// Pointers.
+// Append a boolean value (true/false).
+StringBuilder &operator<<(StringBuilder &builder, bool value);
+
+// Append a pointer.
 StringBuilder &operator<<(StringBuilder &builder, const void *value);
 
-// Zero-terminated strings.
-inline StringBuilder &operator<<(StringBuilder &builder, const char *value) {
-  if (!builder) {
-    return builder;
-  }
-  if (!value) {
-    return builder.append("nullptr", 7);
-  }
-  return builder.append(value, std::strlen(value));
-}
+// Append a zero-terminated string.
+StringBuilder &operator<<(StringBuilder &builder, const char *value);
 
-// A sequence of bytes.
+// Append a sequence of bytes.
 StringBuilder &operator<<(StringBuilder &builder, const Bytes &bytes);
 
-// Exceptions.
+// Append an exception.
 StringBuilder &operator<<(StringBuilder &builder,
                           const std::exception &exception);
 
-------------- next part --------------
HTML����������������������������...
Download 



More information about the Groonga-commit mailing list
Back to archive index