• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 #ifndef BASE_UTF_OFFSET_STRING_CONVERSIONS_H_
6 #define BASE_UTF_OFFSET_STRING_CONVERSIONS_H_
7 #pragma once
8 
9 #include <string>
10 #include <vector>
11 
12 #include "base/base_api.h"
13 #include "base/string16.h"
14 
15 namespace base {
16 class StringPiece;
17 }
18 
19 // Like the conversions in utf_string_conversions.h, but also takes one or more
20 // offsets (|offset[s]_for_adjustment|) into the source strings, each offset
21 // will be adjusted to point at the same logical place in the result strings.
22 // If this isn't possible because an offset points past the end of the source
23 // strings or into the middle of a multibyte sequence, the offending offset will
24 // be set to std::wstring::npos. |offset[s]_for_adjustment| may be NULL.
25 BASE_API bool UTF8ToWideAndAdjustOffset(const char* src,
26                                         size_t src_len,
27                                         std::wstring* output,
28                                         size_t* offset_for_adjustment);
29 BASE_API bool UTF8ToWideAndAdjustOffsets(
30     const char* src,
31     size_t src_len,
32     std::wstring* output,
33     std::vector<size_t>* offsets_for_adjustment);
34 
35 BASE_API std::wstring UTF8ToWideAndAdjustOffset(const base::StringPiece& utf8,
36                                                 size_t* offset_for_adjustment);
37 BASE_API std::wstring UTF8ToWideAndAdjustOffsets(
38     const base::StringPiece& utf8,
39     std::vector<size_t>* offsets_for_adjustment);
40 
41 BASE_API bool UTF16ToWideAndAdjustOffset(const char16* src,
42                                          size_t src_len,
43                                          std::wstring* output,
44                                          size_t* offset_for_adjustment);
45 BASE_API bool UTF16ToWideAndAdjustOffsets(
46     const char16* src,
47     size_t src_len,
48     std::wstring* output,
49     std::vector<size_t>* offsets_for_adjustment);
50 
51 BASE_API std::wstring UTF16ToWideAndAdjustOffset(const string16& utf16,
52                                                  size_t* offset_for_adjustment);
53 BASE_API std::wstring UTF16ToWideAndAdjustOffsets(
54     const string16& utf16,
55     std::vector<size_t>* offsets_for_adjustment);
56 
57 // Limiting function callable by std::for_each which will replace any value
58 // which is equal to or greater than |limit| with npos.
59 template <typename T>
60 struct LimitOffset {
LimitOffsetLimitOffset61   explicit LimitOffset(size_t limit)
62     : limit_(limit) {}
63 
operatorLimitOffset64   void operator()(size_t& offset) {
65     if (offset >= limit_)
66       offset = T::npos;
67   }
68 
69   size_t limit_;
70 };
71 
72 // Adjustment function called by std::transform which will adjust any offset
73 // that occurs after one or more modified substrings. To use, create any
74 // number of AdjustOffset::Adjustments, drop them into a vector, then call
75 // std::transform with the transform function being something similar to
76 // AdjustOffset(adjustments). Each Adjustment gives the original |location|
77 // of the encoded section and the |old_length| and |new_length| of the section
78 // before and after decoding.
79 struct AdjustOffset {
80   // Helper structure which indicates where an encoded character occurred
81   // and how long that encoding was.
82   struct Adjustment {
83     Adjustment(size_t location, size_t old_length, size_t new_length);
84 
85     size_t location;
86     size_t old_length;
87     size_t new_length;
88   };
89 
90   typedef std::vector<Adjustment> Adjustments;
91 
92   explicit AdjustOffset(const Adjustments& adjustments);
93   void operator()(size_t& offset);
94 
95   const Adjustments& adjustments_;
96 };
97 
98 #endif  // BASE_UTF_OFFSET_STRING_CONVERSIONS_H_
99