| OLD | NEW |
| (Empty) |
| 1 // Copyright (c) 2009 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_I18N_STRING_CONVERSIONS_H_ | |
| 6 #define BASE_I18N_STRING_CONVERSIONS_H_ | |
| 7 | |
| 8 #include <string> | |
| 9 | |
| 10 #include "base/string16.h" | |
| 11 #include "base/string_piece.h" | |
| 12 | |
| 13 // These convert between UTF-8, -16, and -32 strings. They are potentially slow, | |
| 14 // so avoid unnecessary conversions. The low-level versions return a boolean | |
| 15 // indicating whether the conversion was 100% valid. In this case, it will still | |
| 16 // do the best it can and put the result in the output buffer. The versions that | |
| 17 // return strings ignore this error and just return the best conversion | |
| 18 // possible. | |
| 19 // | |
| 20 // Note that only the structural validity is checked and non-character | |
| 21 // codepoints and unassigned are regarded as valid. | |
| 22 // TODO(jungshik): Consider replacing an invalid input sequence with | |
| 23 // the Unicode replacement character or adding |replacement_char| parameter. | |
| 24 // Currently, it's skipped in the ouput, which could be problematic in | |
| 25 // some situations. | |
| 26 bool WideToUTF8(const wchar_t* src, size_t src_len, std::string* output); | |
| 27 std::string WideToUTF8(const std::wstring& wide); | |
| 28 bool UTF8ToWide(const char* src, size_t src_len, std::wstring* output); | |
| 29 std::wstring UTF8ToWide(const base::StringPiece& utf8); | |
| 30 | |
| 31 bool WideToUTF16(const wchar_t* src, size_t src_len, string16* output); | |
| 32 string16 WideToUTF16(const std::wstring& wide); | |
| 33 bool UTF16ToWide(const char16* src, size_t src_len, std::wstring* output); | |
| 34 std::wstring UTF16ToWide(const string16& utf16); | |
| 35 | |
| 36 bool UTF8ToUTF16(const char* src, size_t src_len, string16* output); | |
| 37 string16 UTF8ToUTF16(const std::string& utf8); | |
| 38 bool UTF16ToUTF8(const char16* src, size_t src_len, std::string* output); | |
| 39 std::string UTF16ToUTF8(const string16& utf16); | |
| 40 | |
| 41 // We are trying to get rid of wstring as much as possible, but it's too big | |
| 42 // a mess to do it all at once. These conversions should be used when we | |
| 43 // really should just be passing a string16 around, but we haven't finished | |
| 44 // porting whatever module uses wstring and the conversion is being used as a | |
| 45 // stopcock. This makes it easy to grep for the ones that should be removed. | |
| 46 #if defined(OS_WIN) | |
| 47 # define WideToUTF16Hack | |
| 48 # define UTF16ToWideHack | |
| 49 #else | |
| 50 # define WideToUTF16Hack WideToUTF16 | |
| 51 # define UTF16ToWideHack UTF16ToWide | |
| 52 #endif | |
| 53 | |
| 54 // Defines the error handling modes of UTF16ToCodepage, CodepageToUTF16, | |
| 55 // WideToCodepage and CodepageToWide. | |
| 56 class OnStringUtilConversionError { | |
| 57 public: | |
| 58 enum Type { | |
| 59 // The function will return failure. The output buffer will be empty. | |
| 60 FAIL, | |
| 61 | |
| 62 // The offending characters are skipped and the conversion will proceed as | |
| 63 // if they did not exist. | |
| 64 SKIP, | |
| 65 | |
| 66 // When converting to Unicode, the offending byte sequences are substituted | |
| 67 // by Unicode replacement character (U+FFFD). When converting from Unicode, | |
| 68 // this is the same as SKIP. | |
| 69 SUBSTITUTE, | |
| 70 }; | |
| 71 | |
| 72 private: | |
| 73 OnStringUtilConversionError(); | |
| 74 }; | |
| 75 | |
| 76 // Converts between UTF-16 strings and the encoding specified. If the | |
| 77 // encoding doesn't exist or the encoding fails (when on_error is FAIL), | |
| 78 // returns false. | |
| 79 bool UTF16ToCodepage(const string16& utf16, | |
| 80 const char* codepage_name, | |
| 81 OnStringUtilConversionError::Type on_error, | |
| 82 std::string* encoded); | |
| 83 | |
| 84 bool CodepageToUTF16(const std::string& encoded, | |
| 85 const char* codepage_name, | |
| 86 OnStringUtilConversionError::Type on_error, | |
| 87 string16* utf16); | |
| 88 | |
| 89 // Converts between wide strings and the encoding specified. If the | |
| 90 // encoding doesn't exist or the encoding fails (when on_error is FAIL), | |
| 91 // returns false. | |
| 92 bool WideToCodepage(const std::wstring& wide, | |
| 93 const char* codepage_name, | |
| 94 OnStringUtilConversionError::Type on_error, | |
| 95 std::string* encoded); | |
| 96 bool CodepageToWide(const std::string& encoded, | |
| 97 const char* codepage_name, | |
| 98 OnStringUtilConversionError::Type on_error, | |
| 99 std::wstring* wide); | |
| 100 | |
| 101 #endif // BASE_I18N_STRING_CONVERSIONS_H_ | |
| OLD | NEW |