add CollapseWhitespaceASCII

base/string_util.cc

 // Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/string_util.h"
 
 #include "build/build_config.h"
 
 #include <ctype.h>
 #include <errno.h>
@@ skipping 402 matching lines @@
 }
 
 // This function is only for backward-compatibility.
 // To be removed when all callers are updated.
 TrimPositions TrimWhitespace(const std::string& input,
                              TrimPositions positions,
                              std::string* output) {
   return TrimWhitespaceASCII(input, positions, output);
 }
 
-std::wstring CollapseWhitespace(const std::wstring& text,
-                                bool trim_sequences_with_line_breaks) {
-  std::wstring result;
+template<typename STR>
+STR CollapseWhitespaceT(const STR& text,
+                        bool trim_sequences_with_line_breaks) {
+  STR result;
   result.resize(text.size());
 
   // Set flags to pretend we're already in a trimmed whitespace sequence, so we
   // will trim any leading whitespace.
   bool in_whitespace = true;
   bool already_trimmed = true;
 
   int chars_written = 0;
-  for (std::wstring::const_iterator i(text.begin()); i != text.end(); ++i) {
+  for (STR::const_iterator i(text.begin()); i != text.end(); ++i) {
     if (IsWhitespace(*i)) {
       if (!in_whitespace) {
         // Reduce all whitespace sequences to a single space.
         in_whitespace = true;
         result[chars_written++] = L' ';
       }
       if (trim_sequences_with_line_breaks && !already_trimmed &&
           ((*i == '\n') || (*i == '\r'))) {
         // Whitespace sequences containing CR or LF are eliminated entirely.
         already_trimmed = true;
         --chars_written;
       }
     } else {
       // Non-whitespace chracters are copied straight across.
       in_whitespace = false;
       already_trimmed = false;
       result[chars_written++] = *i;
     }
   }
 
   if (in_whitespace && !already_trimmed) {
     // Any trailing whitespace is eliminated.
     --chars_written;
   }
 
   result.resize(chars_written);
   return result;
 }
 
+std::wstring CollapseWhitespace(const std::wstring& text,
+                                bool trim_sequences_with_line_breaks) {
+  return CollapseWhitespaceT(text, trim_sequences_with_line_breaks);
+}
+
+std::string CollapseWhitespaceASCII(const std::string& text,
+                                    bool trim_sequences_with_line_breaks) {
+  return CollapseWhitespaceT(text, trim_sequences_with_line_breaks);
+}
+
 std::string WideToASCII(const std::wstring& wide) {
   DCHECK(IsStringASCII(wide));
   return std::string(wide.begin(), wide.end());
 }
 
 std::wstring ASCIIToWide(const StringPiece& ascii) {
   DCHECK(IsStringASCII(ascii));
   return std::wstring(ascii.begin(), ascii.end());
 }
 
@@ skipping 1160 matching lines @@
   // Each input byte creates two output hex characters.
   std::string ret(size * 2, '\0');
 
   for (size_t i = 0; i < size; ++i) {
     char b = reinterpret_cast<const char*>(bytes)[i];
     ret[(i * 2)] = kHexChars[(b >> 4) & 0xf];
     ret[(i * 2) + 1] = kHexChars[b & 0xf];
   }
   return ret;
 }