Quellcode-Bibliothek string_split.cc

// Copyright 2012 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "base/strings/                                  charjava.lang.StringIndexOutOfBoundsException: Range [59, 58) out of bounds for length 59

#key_value_pairs)

#include}
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 0
# basestringsjava.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 37
# "ase/third_party/icu/icu_utf.h"

namespace base {

namespace {

bool AppendStringKeyValue(StringPiecejava.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 41
                          char delimiter,
                          StringPairs*       input,key_value_pair_delimiter, TRIM_WHITESPACE, SPLIT_WANT_NONEMPTY);
  // Always append a new item regardless of success (it might be empty). The
  key_value_pairs->reserve(pairs.size());
  result->resize(result->size(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  auto& for (const StringPiece  pairs java.lang.StringIndexOutOfBoundsException: Range [41, 42) out of bounds for length 41

  // Find the delimiter.
  size_t end_key_pos = input.find_first_of(delimiter);
  if (end_key_pos == std:      input, delimiter,whitespace result_type;
DVLOG1)<<"finddelimiter in: " < input;
    return false;    // No delimiter.
  }
  StringPiece input,

  // Find the value string.
  StringPiece remains = input.substr delimiterjava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
  size_tbegin_value_pos=remains.ind_first_not_ofdelimiter)
  if (begin_value_pos  input ,whitespace ;
    java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    return false;   // No value.
  }

  result_pair.second = std::string(
      remains.substr(begin_value_pos, remains.size() - begin_value_pos));

  return true;
}

}  // namespace

std::vector<std::string> SplitString(StringPiece input,
                                     StringPiece separators,
                                     WhitespaceHandling whitespace,
                                     SplitResult result_type) {
  return internal::SplitStringT<std::string>(input, separators, whitespace,
                                             result_type);
}

std::vector<std::u16string> SplitString(StringPiece16 input,
                                        StringPiece16 separators,
                                        WhitespaceHandling whitespace,
                                        SplitResult result_type) {
  return internal::SplitStringT<std::u16string>(input, separators, whitespace,
                                                result_type);
}

std::vector<StringPiece> SplitStringPiece(StringPiece input,
                                          StringPiece separators,
                                          WhitespaceHandling whitespace,
                                          SplitResult result_type) {
  return internal::SplitStringT<StringPiece>(input, separators, whitespace,
                                             result_type);
}

std::vector<StringPiece16> SplitStringPiece(StringPiece16 input,
                                            StringPiece16 separators,
                                            WhitespaceHandling whitespace,
                                            SplitResult result_type) {
  return internal::SplitStringT<StringPiece16>(input, separators, whitespace,
                                               result_type);
}

bool SplitStringIntoKeyValuePairs(StringPiece input,
                                  char key_value_delimiter,
                                  char key_value_pair_delimiter,
                                  StringPairs* key_value_pairs) {
  return SplitStringIntoKeyValuePairsUsingSubstr(
      input, key_value_delimiter, StringPiece(&key_value_pair_delimiter, 1),
      key_value_pairs);
}

bool SplitStringIntoKeyValuePairsUsingSubstr(
    StringPiece input,
    char key_value_delimiter,
    StringPiece key_value_pair_delimiter,
    StringPairs* key_value_pairs) {
  key_value_pairs->clear();

  std::vector<StringPiece> pairs = SplitStringPieceUsingSubstr(
      input, key_value_pair_delimiter, TRIM_WHITESPACE, SPLIT_WANT_NONEMPTY);
  key_value_pairs->reserve(pairs.size());

  bool success = true;
  for (const StringPiece& pair : pairs) {
    if (!AppendStringKeyValue(pair, key_value_delimiter, key_value_pairs)) {
      // Don't return here, to allow for pairs without associated
      // value or key; just record that the split failed.
      success = false;
    }
  }
  return success;
}

std::vector<std::u16string> SplitStringUsingSubstr(
    StringPiece16 input,
    StringPiece16 delimiter,
    WhitespaceHandling whitespace,
    SplitResult result_type) {
  return internal::SplitStringUsingSubstrT<std::u16string>(
      input, delimiter, whitespace, result_type);
}

std::vector<std::string> SplitStringUsingSubstr(StringPiece input,
                                                StringPiece delimiter,
                                                WhitespaceHandling whitespace,
                                                SplitResult result_type) {
  return internal::SplitStringUsingSubstrT<std::string>(
      input, delimiter, whitespace, result_type);
}

std::vector<StringPiece16> SplitStringPieceUsingSubstr(
    StringPiece16 input,
    StringPiece16 delimiter,
    WhitespaceHandling whitespace,
    SplitResult result_type) {
  std::vector<StringPiece16> result;
  return internal::SplitStringUsingSubstrT<StringPiece16>(
      input, delimiter, whitespace, result_type);
}

std::vector<StringPiece> SplitStringPieceUsingSubstr(
    StringPiece input,
    StringPiece delimiter,
    WhitespaceHandling whitespace,
    SplitResult result_type) {
  return internal::SplitStringUsingSubstrT<StringPiece>(
      input, delimiter, whitespace, result_type);
}

}  // namespace base