base/strings/utf_offset_string_conversions.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/strings/utf_offset_string_conversions.h"
   6
   7 #include <algorithm>
   8
   9 #include "base/memory/scoped_ptr.h"
  10 #include "base/strings/string_piece.h"
  11 #include "base/strings/utf_string_conversion_utils.h"
  12
  13 namespace base {
  14
  15 // Converts the given source Unicode character type to the given destination
  16 // Unicode character type as a STL string. The given input buffer and size
  17 // determine the source, and the given output STL string will be replaced by
  18 // the result.
  19 template<typename SrcChar, typename DestStdString>
  20 bool ConvertUnicode(const SrcChar* src,
  21                     size_t src_len,
  22                     DestStdString* output,
  23                     std::vector<size_t>* offsets_for_adjustment) {
  24   if (offsets_for_adjustment) {
  25     std::for_each(offsets_for_adjustment->begin(),
  26                   offsets_for_adjustment->end(),
  27                   LimitOffset<DestStdString>(src_len));
  28   }
  29
  30   // ICU requires 32-bit numbers.
  31   bool success = true;
  32   OffsetAdjuster offset_adjuster(offsets_for_adjustment);
  33   int32 src_len32 = static_cast<int32>(src_len);
  34   for (int32 i = 0; i < src_len32; i++) {
  35     uint32 code_point;
  36     size_t original_i = i;
  37     size_t chars_written = 0;
  38     if (ReadUnicodeCharacter(src, src_len32, &i, &code_point)) {
  39       chars_written = WriteUnicodeCharacter(code_point, output);
  40     } else {
  41       chars_written = WriteUnicodeCharacter(0xFFFD, output);
  42       success = false;
  43     }
  44     if (offsets_for_adjustment) {
  45       // NOTE: ReadUnicodeCharacter() adjusts |i| to point _at_ the last
  46       // character read, not after it (so that incrementing it in the loop
  47       // increment will place it at the right location), so we need to account
  48       // for that in determining the amount that was read.
  49       offset_adjuster.Add(OffsetAdjuster::Adjustment(original_i,
  50           i - original_i + 1, chars_written));
  51     }
  52   }
  53   return success;
  54 }
  55
  56 bool UTF8ToUTF16AndAdjustOffset(const char* src,
  57                                 size_t src_len,
  58                                 string16* output,
  59                                 size_t* offset_for_adjustment) {
  60   std::vector<size_t> offsets;
  61   if (offset_for_adjustment)
  62     offsets.push_back(*offset_for_adjustment);
  63   PrepareForUTF16Or32Output(src, src_len, output);
  64   bool ret = ConvertUnicode(src, src_len, output, &offsets);
  65   if (offset_for_adjustment)
  66     *offset_for_adjustment = offsets[0];
  67   return ret;
  68 }
  69
  70 bool UTF8ToUTF16AndAdjustOffsets(const char* src,
  71                                  size_t src_len,
  72                                  string16* output,
  73                                  std::vector<size_t>* offsets_for_adjustment) {
  74   PrepareForUTF16Or32Output(src, src_len, output);
  75   return ConvertUnicode(src, src_len, output, offsets_for_adjustment);
  76 }
  77
  78 string16 UTF8ToUTF16AndAdjustOffset(const base::StringPiece& utf8,
  79                                         size_t* offset_for_adjustment) {
  80   std::vector<size_t> offsets;
  81   if (offset_for_adjustment)
  82     offsets.push_back(*offset_for_adjustment);
  83   string16 result;
  84   UTF8ToUTF16AndAdjustOffsets(utf8.data(), utf8.length(), &result,
  85                               &offsets);
  86   if (offset_for_adjustment)
  87     *offset_for_adjustment = offsets[0];
  88   return result;
  89 }
  90
  91 string16 UTF8ToUTF16AndAdjustOffsets(
  92     const base::StringPiece& utf8,
  93     std::vector<size_t>* offsets_for_adjustment) {
  94   string16 result;
  95   UTF8ToUTF16AndAdjustOffsets(utf8.data(), utf8.length(), &result,
  96                               offsets_for_adjustment);
  97   return result;
  98 }
  99
 100 std::string UTF16ToUTF8AndAdjustOffset(
 101     const base::StringPiece16& utf16,
 102     size_t* offset_for_adjustment) {
 103   std::vector<size_t> offsets;
 104   if (offset_for_adjustment)
 105     offsets.push_back(*offset_for_adjustment);
 106   std::string result = UTF16ToUTF8AndAdjustOffsets(utf16, &offsets);
 107   if (offset_for_adjustment)
 108     *offset_for_adjustment = offsets[0];
 109   return result;
 110 }
 111
 112 std::string UTF16ToUTF8AndAdjustOffsets(
 113     const base::StringPiece16& utf16,
 114     std::vector<size_t>* offsets_for_adjustment) {
 115   std::string result;
 116   PrepareForUTF8Output(utf16.data(), utf16.length(), &result);
 117   ConvertUnicode(utf16.data(), utf16.length(), &result, offsets_for_adjustment);
 118   return result;
 119 }
 120
 121 OffsetAdjuster::Adjustment::Adjustment(size_t original_offset,
 122                                        size_t original_length,
 123                                        size_t output_length)
 124     : original_offset(original_offset),
 125       original_length(original_length),
 126       output_length(output_length) {
 127 }
 128
 129 OffsetAdjuster::OffsetAdjuster(std::vector<size_t>* offsets_for_adjustment)
 130     : offsets_for_adjustment_(offsets_for_adjustment) {
 131 }
 132
 133 OffsetAdjuster::~OffsetAdjuster() {
 134   if (!offsets_for_adjustment_ || adjustments_.empty())
 135     return;
 136   for (std::vector<size_t>::iterator i(offsets_for_adjustment_->begin());
 137        i != offsets_for_adjustment_->end(); ++i)
 138     AdjustOffset(i);
 139 }
 140
 141 void OffsetAdjuster::Add(const Adjustment& adjustment) {
 142   adjustments_.push_back(adjustment);
 143 }
 144
 145 void OffsetAdjuster::AdjustOffset(std::vector<size_t>::iterator offset) {
 146   if (*offset == string16::npos)
 147     return;
 148   size_t adjustment = 0;
 149   for (std::vector<Adjustment>::const_iterator i = adjustments_.begin();
 150        i != adjustments_.end(); ++i) {
 151     if (*offset == i->original_offset && i->output_length == 0) {
 152       *offset = string16::npos;
 153       return;
 154     }
 155     if (*offset <= i->original_offset)
 156       break;
 157     if (*offset < (i->original_offset + i->original_length)) {
 158       *offset = string16::npos;
 159       return;
 160     }
 161     adjustment += (i->original_length - i->output_length);
 162   }
 163   *offset -= adjustment;
 164 }
 165
 166 }  // namespace base