OLD | NEW |
1 // Copyright (c) 2011 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #ifndef BASE_STRING_NUMBER_CONVERSIONS_H_ | 5 #ifndef BASE_STRING_NUMBER_CONVERSIONS_H_ |
6 #define BASE_STRING_NUMBER_CONVERSIONS_H_ | 6 #define BASE_STRING_NUMBER_CONVERSIONS_H_ |
7 | 7 |
8 #include <string> | 8 #include <string> |
9 #include <vector> | 9 #include <vector> |
10 | 10 |
11 #include "base/base_export.h" | 11 #include "base/base_export.h" |
12 #include "base/basictypes.h" | 12 #include "base/basictypes.h" |
13 #include "base/string_piece.h" | |
14 #include "base/string16.h" | 13 #include "base/string16.h" |
15 | 14 |
16 // ---------------------------------------------------------------------------- | 15 // ---------------------------------------------------------------------------- |
17 // IMPORTANT MESSAGE FROM YOUR SPONSOR | 16 // IMPORTANT MESSAGE FROM YOUR SPONSOR |
18 // | 17 // |
19 // This file contains no "wstring" variants. New code should use string16. If | 18 // This file contains no "wstring" variants. New code should use string16. If |
20 // you need to make old code work, use the UTF8 version and convert. Please do | 19 // you need to make old code work, use the UTF8 version and convert. Please do |
21 // not add wstring variants. | 20 // not add wstring variants. |
22 // | 21 // |
23 // Please do not add "convenience" functions for converting strings to integers | 22 // Please do not add "convenience" functions for converting strings to integers |
(...skipping 28 matching lines...) Expand all Loading... |
52 // "perfect" conversions; returns false in the following cases: | 51 // "perfect" conversions; returns false in the following cases: |
53 // - Overflow/underflow. |*output| will be set to the maximum value supported | 52 // - Overflow/underflow. |*output| will be set to the maximum value supported |
54 // by the data type. | 53 // by the data type. |
55 // - Trailing characters in the string after parsing the number. |*output| | 54 // - Trailing characters in the string after parsing the number. |*output| |
56 // will be set to the value of the number that was parsed. | 55 // will be set to the value of the number that was parsed. |
57 // - Leading whitespace in the string before parsing the number. |*output| will | 56 // - Leading whitespace in the string before parsing the number. |*output| will |
58 // be set to the value of the number that was parsed. | 57 // be set to the value of the number that was parsed. |
59 // - No characters parseable as a number at the beginning of the string. | 58 // - No characters parseable as a number at the beginning of the string. |
60 // |*output| will be set to 0. | 59 // |*output| will be set to 0. |
61 // - Empty string. |*output| will be set to 0. | 60 // - Empty string. |*output| will be set to 0. |
62 BASE_EXPORT bool StringToInt(const StringPiece& input, int* output); | 61 BASE_EXPORT bool StringToInt(const std::string& input, int* output); |
63 BASE_EXPORT bool StringToInt(const StringPiece16& input, int* output); | 62 BASE_EXPORT bool StringToInt(std::string::const_iterator begin, |
64 BASE_EXPORT bool StringToInt64(const StringPiece& input, int64* output); | 63 std::string::const_iterator end, |
65 BASE_EXPORT bool StringToInt64(const StringPiece16& input, int64* output); | 64 int* output); |
| 65 BASE_EXPORT bool StringToInt(const char* begin, const char* end, int* output); |
| 66 |
| 67 BASE_EXPORT bool StringToInt(const string16& input, int* output); |
| 68 BASE_EXPORT bool StringToInt(string16::const_iterator begin, |
| 69 string16::const_iterator end, |
| 70 int* output); |
| 71 BASE_EXPORT bool StringToInt(const char16* begin, const char16* end, |
| 72 int* output); |
| 73 |
| 74 BASE_EXPORT bool StringToInt64(const std::string& input, int64* output); |
| 75 BASE_EXPORT bool StringToInt64(std::string::const_iterator begin, |
| 76 std::string::const_iterator end, |
| 77 int64* output); |
| 78 BASE_EXPORT bool StringToInt64(const char* begin, const char* end, |
| 79 int64* output); |
| 80 |
| 81 BASE_EXPORT bool StringToInt64(const string16& input, int64* output); |
| 82 BASE_EXPORT bool StringToInt64(string16::const_iterator begin, |
| 83 string16::const_iterator end, |
| 84 int64* output); |
| 85 BASE_EXPORT bool StringToInt64(const char16* begin, const char16* end, |
| 86 int64* output); |
66 | 87 |
67 // For floating-point conversions, only conversions of input strings in decimal | 88 // For floating-point conversions, only conversions of input strings in decimal |
68 // form are defined to work. Behavior with strings representing floating-point | 89 // form are defined to work. Behavior with strings representing floating-point |
69 // numbers in hexadecimal, and strings representing non-fininte values (such as | 90 // numbers in hexadecimal, and strings representing non-fininte values (such as |
70 // NaN and inf) is undefined. Otherwise, these behave the same as the integral | 91 // NaN and inf) is undefined. Otherwise, these behave the same as the integral |
71 // variants. This expects the input string to NOT be specific to the locale. | 92 // variants. This expects the input string to NOT be specific to the locale. |
72 // If your input is locale specific, use ICU to read the number. | 93 // If your input is locale specific, use ICU to read the number. |
73 BASE_EXPORT bool StringToDouble(const std::string& input, double* output); | 94 BASE_EXPORT bool StringToDouble(const std::string& input, double* output); |
74 | 95 |
75 // Hex encoding ---------------------------------------------------------------- | 96 // Hex encoding ---------------------------------------------------------------- |
76 | 97 |
77 // Returns a hex string representation of a binary buffer. The returned hex | 98 // Returns a hex string representation of a binary buffer. The returned hex |
78 // string will be in upper case. This function does not check if |size| is | 99 // string will be in upper case. This function does not check if |size| is |
79 // within reasonable limits since it's written with trusted data in mind. If | 100 // within reasonable limits since it's written with trusted data in mind. If |
80 // you suspect that the data you want to format might be large, the absolute | 101 // you suspect that the data you want to format might be large, the absolute |
81 // max size for |size| should be is | 102 // max size for |size| should be is |
82 // std::numeric_limits<size_t>::max() / 2 | 103 // std::numeric_limits<size_t>::max() / 2 |
83 BASE_EXPORT std::string HexEncode(const void* bytes, size_t size); | 104 BASE_EXPORT std::string HexEncode(const void* bytes, size_t size); |
84 | 105 |
85 // Best effort conversion, see StringToInt above for restrictions. | 106 // Best effort conversion, see StringToInt above for restrictions. |
86 BASE_EXPORT bool HexStringToInt(const StringPiece& input, int* output); | 107 BASE_EXPORT bool HexStringToInt(const std::string& input, int* output); |
| 108 BASE_EXPORT bool HexStringToInt(std::string::const_iterator begin, |
| 109 std::string::const_iterator end, |
| 110 int* output); |
| 111 BASE_EXPORT bool HexStringToInt(const char* begin, const char* end, |
| 112 int* output); |
87 | 113 |
88 // Similar to the previous functions, except that output is a vector of bytes. | 114 // Similar to the previous functions, except that output is a vector of bytes. |
89 // |*output| will contain as many bytes as were successfully parsed prior to the | 115 // |*output| will contain as many bytes as were successfully parsed prior to the |
90 // error. There is no overflow, but input.size() must be evenly divisible by 2. | 116 // error. There is no overflow, but input.size() must be evenly divisible by 2. |
91 // Leading 0x or +/- are not allowed. | 117 // Leading 0x or +/- are not allowed. |
92 BASE_EXPORT bool HexStringToBytes(const std::string& input, | 118 BASE_EXPORT bool HexStringToBytes(const std::string& input, |
93 std::vector<uint8>* output); | 119 std::vector<uint8>* output); |
94 | 120 |
95 } // namespace base | 121 } // namespace base |
96 | 122 |
97 #endif // BASE_STRING_NUMBER_CONVERSIONS_H_ | 123 #endif // BASE_STRING_NUMBER_CONVERSIONS_H_ |
98 | 124 |
OLD | NEW |