base/string_split.cc

   1 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/string_split.h"
   6
   7 #include "base/logging.h"
   8 #include "base/string_util.h"
   9 #include "base/third_party/icu/icu_utf.h"
  10 #include "base/utf_string_conversions.h"
  11
  12 namespace base {
  13
  14 template<typename STR>
  15 static void SplitStringT(const STR& str,
  16                          const typename STR::value_type s,
  17                          bool trim_whitespace,
  18                          std::vector<STR>* r) {
  19   size_t last = 0;
  20   size_t i;
  21   size_t c = str.size();
  22   for (i = 0; i <= c; ++i) {
  23     if (i == c || str[i] == s) {
  24       size_t len = i - last;
  25       STR tmp = str.substr(last, len);
  26       if (trim_whitespace) {
  27         STR t_tmp;
  28         TrimWhitespace(tmp, TRIM_ALL, &t_tmp);
  29         r->push_back(t_tmp);
  30       } else {
  31         r->push_back(tmp);
  32       }
  33       last = i + 1;
  34     }
  35   }
  36 }
  37
  38 void SplitString(const string16& str,
  39                  char16 c,
  40                  std::vector<string16>* r) {
  41   DCHECK(CBU16_IS_SINGLE(c));
  42   SplitStringT(str, c, true, r);
  43 }
  44
  45 void SplitString(const std::string& str,
  46                  char c,
  47                  std::vector<std::string>* r) {
  48   DCHECK(c >= 0 && c < 0x7F);
  49   SplitStringT(str, c, true, r);
  50 }
  51
  52 bool SplitStringIntoKeyValues(
  53     const std::string& line,
  54     char key_value_delimiter,
  55     std::string* key, std::vector<std::string>* values) {
  56   key->clear();
  57   values->clear();
  58
  59   // Find the key string.
  60   size_t end_key_pos = line.find_first_of(key_value_delimiter);
  61   if (end_key_pos == std::string::npos) {
  62     DVLOG(1) << "cannot parse key from line: " << line;
  63     return false;    // no key
  64   }
  65   key->assign(line, 0, end_key_pos);
  66
  67   // Find the values string.
  68   std::string remains(line, end_key_pos, line.size() - end_key_pos);
  69   size_t begin_values_pos = remains.find_first_not_of(key_value_delimiter);
  70   if (begin_values_pos == std::string::npos) {
  71     DVLOG(1) << "cannot parse value from line: " << line;
  72     return false;   // no value
  73   }
  74   std::string values_string(remains, begin_values_pos,
  75                             remains.size() - begin_values_pos);
  76
  77   // Construct the values vector.
  78   values->push_back(values_string);
  79   return true;
  80 }
  81
  82 bool SplitStringIntoKeyValuePairs(
  83     const std::string& line,
  84     char key_value_delimiter,
  85     char key_value_pair_delimiter,
  86     std::vector<std::pair<std::string, std::string> >* kv_pairs) {
  87   kv_pairs->clear();
  88
  89   std::vector<std::string> pairs;
  90   SplitString(line, key_value_pair_delimiter, &pairs);
  91
  92   bool success = true;
  93   for (size_t i = 0; i < pairs.size(); ++i) {
  94     // Empty pair. SplitStringIntoKeyValues is more strict about an empty pair
  95     // line, so continue with the next pair.
  96     if (pairs[i].empty())
  97       continue;
  98
  99     std::string key;
 100     std::vector<std::string> value;
 101     if (!SplitStringIntoKeyValues(pairs[i],
 102                                   key_value_delimiter,
 103                                   &key, &value)) {
 104       // Don't return here, to allow for keys without associated
 105       // values; just record that our split failed.
 106       success = false;
 107     }
 108     DCHECK_LE(value.size(), 1U);
 109     kv_pairs->push_back(make_pair(key, value.empty()? "" : value[0]));
 110   }
 111   return success;
 112 }
 113
 114 template <typename STR>
 115 static void SplitStringUsingSubstrT(const STR& str,
 116                                     const STR& s,
 117                                     std::vector<STR>* r) {
 118   typename STR::size_type begin_index = 0;
 119   while (true) {
 120     const typename STR::size_type end_index = str.find(s, begin_index);
 121     if (end_index == STR::npos) {
 122       const STR term = str.substr(begin_index);
 123       STR tmp;
 124       TrimWhitespace(term, TRIM_ALL, &tmp);
 125       r->push_back(tmp);
 126       return;
 127     }
 128     const STR term = str.substr(begin_index, end_index - begin_index);
 129     STR tmp;
 130     TrimWhitespace(term, TRIM_ALL, &tmp);
 131     r->push_back(tmp);
 132     begin_index = end_index + s.size();
 133   }
 134 }
 135
 136 void SplitStringUsingSubstr(const string16& str,
 137                             const string16& s,
 138                             std::vector<string16>* r) {
 139   SplitStringUsingSubstrT(str, s, r);
 140 }
 141
 142 void SplitStringUsingSubstr(const std::string& str,
 143                             const std::string& s,
 144                             std::vector<std::string>* r) {
 145   SplitStringUsingSubstrT(str, s, r);
 146 }
 147
 148 void SplitStringDontTrim(const string16& str,
 149                          char16 c,
 150                          std::vector<string16>* r) {
 151   DCHECK(CBU16_IS_SINGLE(c));
 152   SplitStringT(str, c, false, r);
 153 }
 154
 155 void SplitStringDontTrim(const std::string& str,
 156                          char c,
 157                          std::vector<std::string>* r) {
 158   DCHECK(IsStringUTF8(str));
 159   DCHECK(c >= 0 && c < 0x7F);
 160   SplitStringT(str, c, false, r);
 161 }
 162
 163 template<typename STR>
 164 void SplitStringAlongWhitespaceT(const STR& str, std::vector<STR>* result) {
 165   const size_t length = str.length();
 166   if (!length)
 167     return;
 168
 169   bool last_was_ws = false;
 170   size_t last_non_ws_start = 0;
 171   for (size_t i = 0; i < length; ++i) {
 172     switch (str[i]) {
 173       // HTML 5 defines whitespace as: space, tab, LF, line tab, FF, or CR.
 174       case L' ':
 175       case L'\t':
 176       case L'\xA':
 177       case L'\xB':
 178       case L'\xC':
 179       case L'\xD':
 180         if (!last_was_ws) {
 181           if (i > 0) {
 182             result->push_back(
 183                 str.substr(last_non_ws_start, i - last_non_ws_start));
 184           }
 185           last_was_ws = true;
 186         }
 187         break;
 188
 189       default:  // Not a space character.
 190         if (last_was_ws) {
 191           last_was_ws = false;
 192           last_non_ws_start = i;
 193         }
 194         break;
 195     }
 196   }
 197   if (!last_was_ws) {
 198     result->push_back(
 199         str.substr(last_non_ws_start, length - last_non_ws_start));
 200   }
 201 }
 202
 203 void SplitStringAlongWhitespace(const std::wstring& str,
 204                                 std::vector<std::wstring>* result) {
 205   SplitStringAlongWhitespaceT(str, result);
 206 }
 207
 208 #if !defined(WCHAR_T_IS_UTF16)
 209 void SplitStringAlongWhitespace(const string16& str,
 210                                 std::vector<string16>* result) {
 211   SplitStringAlongWhitespaceT(str, result);
 212 }
 213 #endif
 214
 215 void SplitStringAlongWhitespace(const std::string& str,
 216                                 std::vector<std::string>* result) {
 217   SplitStringAlongWhitespaceT(str, result);
 218 }
 219
 220 }  // namespace base