base_string-Aet

Bingliaolong 2021-05-19 13:35 Aet | 隐藏边栏 | 抢沙发 | 0 0

文章评分 0 次，平均分 0.0 ：

string_piece_forward

namespace base {

template <typename STRING_TYPE>

class BasicStringPiece;

typedef BasicStringPiece<std::string> StringPiece;

typedef BasicStringPiece<string16> StringPiece16;

typedef BasicStringPiece<std::wstring> WStringPiece;

} // namespace base

strcat

Strcat

BASE_EXPORT std::string StrCat(span<const StringPiece> pieces);

BASE_EXPORT string16 StrCat(span<const StringPiece16> pieces);

BASE_EXPORT std::string StrCat(span<const std::string> pieces);

BASE_EXPORT string16 StrCat(span<const string16> pieces);

StrAppend

BASE_EXPORT void StrAppend(std::string* dest, span<const StringPiece> pieces);

BASE_EXPORT void StrAppend(string16* dest, span<const StringPiece16> pieces);

BASE_EXPORT void StrAppend(std::string* dest, span<const std::string> pieces);

BASE_EXPORT void StrAppend(string16* dest, span<const string16> pieces);

string_number_conversions

Number -> string

BASE_EXPORT std::string NumberToString(int value);

BASE_EXPORT string16 NumberToString16(int value);

BASE_EXPORT std::string NumberToString(unsigned int value);

BASE_EXPORT string16 NumberToString16(unsigned int value);

BASE_EXPORT std::string NumberToString(long value);

BASE_EXPORT string16 NumberToString16(long value);

BASE_EXPORT std::string NumberToString(unsigned long value);

BASE_EXPORT string16 NumberToString16(unsigned long value);

BASE_EXPORT std::string NumberToString(long long value);

BASE_EXPORT string16 NumberToString16(long long value);

BASE_EXPORT std::string NumberToString(unsigned long long value);

BASE_EXPORT string16 NumberToString16(unsigned long long value);

BASE_EXPORT std::string NumberToString(double value);

BASE_EXPORT string16 NumberToString16(double value);

String -> number

BASE_EXPORT bool StringToInt(StringPiece input, int* output);

BASE_EXPORT bool StringToInt(StringPiece16 input, int* output);

BASE_EXPORT bool StringToUint(StringPiece input, unsigned* output);

BASE_EXPORT bool StringToUint(StringPiece16 input, unsigned* output);

BASE_EXPORT bool StringToInt64(StringPiece input, int64_t* output);

BASE_EXPORT bool StringToInt64(StringPiece16 input, int64_t* output);

BASE_EXPORT bool StringToUint64(StringPiece input, uint64_t* output);

BASE_EXPORT bool StringToUint64(StringPiece16 input, uint64_t* output);

BASE_EXPORT bool StringToSizeT(StringPiece input, size_t* output);

BASE_EXPORT bool StringToSizeT(StringPiece16 input, size_t* output);

BASE_EXPORT bool StringToDouble(StringPiece input, double* output);

BASE_EXPORT bool StringToDouble(StringPiece16 input, double* output);

16进制相关的转换

1 2	BASE_EXPORT std::string HexEncode(const void* bytes, size_t size); BASE_EXPORT std::string HexEncode(base::span<const uint8_t> bytes);

// -0x80000000 < |input| < 0x7FFFFFFF.

BASE_EXPORT bool HexStringToInt(StringPiece input, int* output);

// 0x00000000 < |input| < 0xFFFFFFFF.

// The string is not required to start with 0x.

BASE_EXPORT bool HexStringToUInt(StringPiece input, uint32_t* output);

// -0x8000000000000000 < |input| < 0x7FFFFFFFFFFFFFFF.

BASE_EXPORT bool HexStringToInt64(StringPiece input, int64_t* output);

// 0x0000000000000000 < |input| < 0xFFFFFFFFFFFFFFFF.

// The string is not required to start with 0x.

BASE_EXPORT bool HexStringToUInt64(StringPiece input, uint64_t* output);

// Leading 0x or +/- are not allowed.

BASE_EXPORT bool HexStringToBytes(StringPiece input,

std::vector<uint8_t>* output);

string_piece

base::internal

BASE_EXPORT void CopyToString(const StringPiece& self, std::string* target);

BASE_EXPORT void CopyToString(const StringPiece16& self, string16* target);

BASE_EXPORT void AppendToString(const StringPiece& self, std::string* target);

BASE_EXPORT void AppendToString(const StringPiece16& self, string16* target);

BASE_EXPORT size_t copy(const StringPiece& self,

char* buf,

size_t n,

size_t pos);

BASE_EXPORT size_t copy(const StringPiece16& self,

char16* buf,

size_t n,

size_t pos);

BASE_EXPORT size_t find(const StringPiece& self,

const StringPiece& s,

size_t pos);

BASE_EXPORT size_t find(const StringPiece16& self,

const StringPiece16& s,

size_t pos);

BASE_EXPORT size_t find(const StringPiece& self,

char c,

size_t pos);

BASE_EXPORT size_t find(const StringPiece16& self,

char16 c,

size_t pos);

BASE_EXPORT size_t rfind(const StringPiece& self,

const StringPiece& s,

size_t pos);

BASE_EXPORT size_t rfind(const StringPiece16& self,

const StringPiece16& s,

size_t pos);

BASE_EXPORT size_t rfind(const StringPiece& self,

char c,

size_t pos);

BASE_EXPORT size_t rfind(const StringPiece16& self,

char16 c,

size_t pos);

BASE_EXPORT size_t find_first_of(const StringPiece& self,

const StringPiece& s,

size_t pos);

BASE_EXPORT size_t find_first_of(const StringPiece16& self,

const StringPiece16& s,

size_t pos);

BASE_EXPORT size_t find_first_not_of(const StringPiece& self,

const StringPiece& s,

size_t pos);

BASE_EXPORT size_t find_first_not_of(const StringPiece16& self,

const StringPiece16& s,

size_t pos);

BASE_EXPORT size_t find_first_not_of(const StringPiece& self,

char c,

size_t pos);

BASE_EXPORT size_t find_first_not_of(const StringPiece16& self,

char16 c,

size_t pos);

BASE_EXPORT size_t find_last_of(const StringPiece& self,

const StringPiece& s,

size_t pos);

BASE_EXPORT size_t find_last_of(const StringPiece16& self,

const StringPiece16& s,

size_t pos);

BASE_EXPORT size_t find_last_of(const StringPiece& self,

char c,

size_t pos);

BASE_EXPORT size_t find_last_of(const StringPiece16& self,

char16 c,

size_t pos);

BASE_EXPORT size_t find_last_not_of(const StringPiece& self,

const StringPiece& s,

size_t pos);

BASE_EXPORT size_t find_last_not_of(const StringPiece16& self,

const StringPiece16& s,

size_t pos);

BASE_EXPORT size_t find_last_not_of(const StringPiece16& self,

char16 c,

size_t pos);

BASE_EXPORT size_t find_last_not_of(const StringPiece& self,

char c,

size_t pos);

BASE_EXPORT StringPiece substr(const StringPiece& self,

size_t pos,

size_t n);

BASE_EXPORT StringPiece16 substr(const StringPiece16& self,

size_t pos,

size_t n);

string_split

分割类型

如果输入为“ ,,”且分隔符为“，”将返回三个空字符串向量。不会忽略空的结果
仅非空结果将被添加到结果中。多个分隔符将合并。输入开头和结尾处的分隔符将被忽略。使用TRIM_WHITESPACE，仅空白结果将被删除。

enum WhitespaceHandling {

KEEP_WHITESPACE,

TRIM_WHITESPACE,

};

enum SplitResult {

SPLIT_WANT_ALL,

SPLIT_WANT_NONEMPTY,

};

方法

BASE_EXPORT std::vector<std::string> SplitString(

StringPiece input,

StringPiece separators,

WhitespaceHandling whitespace,

SplitResult result_type);

BASE_EXPORT std::vector<string16> SplitString(

StringPiece16 input,

StringPiece16 separators,

WhitespaceHandling whitespace,

SplitResult result_type);

BASE_EXPORT std::vector<StringPiece> SplitStringPiece(

StringPiece input,

StringPiece separators,

WhitespaceHandling whitespace,

SplitResult result_type);

BASE_EXPORT std::vector<StringPiece16> SplitStringPiece(

StringPiece16 input,

StringPiece16 separators,

WhitespaceHandling whitespace,

SplitResult result_type);

BASE_EXPORT bool SplitStringIntoKeyValuePairs(StringPiece input,

char key_value_delimiter,

char key_value_pair_delimiter,

StringPairs* key_value_pairs);

BASE_EXPORT bool SplitStringIntoKeyValuePairsUsingSubstr(

StringPiece input,

char key_value_delimiter,

StringPiece key_value_pair_delimiter,

StringPairs* key_value_pairs);

BASE_EXPORT std::vector<string16> SplitStringUsingSubstr(

StringPiece16 input,

StringPiece16 delimiter,

WhitespaceHandling whitespace,

SplitResult result_type);

BASE_EXPORT std::vector<std::string> SplitStringUsingSubstr(

StringPiece input,

StringPiece delimiter,

WhitespaceHandling whitespace,

SplitResult result_type);

BASE_EXPORT std::vector<StringPiece16> SplitStringPieceUsingSubstr(

StringPiece16 input,

StringPiece16 delimiter,

WhitespaceHandling whitespace,

SplitResult result_type);

BASE_EXPORT std::vector<StringPiece> SplitStringPieceUsingSubstr(

StringPiece input,

StringPiece delimiter,

WhitespaceHandling whitespace,

SplitResult result_type);

// 关于宽字符

BASE_EXPORT std::vector<std::wstring> SplitString(WStringPiece input,

WStringPiece separators,

WhitespaceHandling whitespace,

SplitResult result_type);

BASE_EXPORT std::vector<WStringPiece> SplitStringPiece(

WStringPiece input,

WStringPiece separators,

WhitespaceHandling whitespace,

SplitResult result_type);

BASE_EXPORT std::vector<std::wstring> SplitStringUsingSubstr(

WStringPiece input,

WStringPiece delimiter,

WhitespaceHandling whitespace,

SplitResult result_type);

BASE_EXPORT std::vector<WStringPiece> SplitStringPieceUsingSubstr(

WStringPiece input,

WStringPiece delimiter,

WhitespaceHandling whitespace,

SplitResult result_type);

string_util

base::

拷贝

1 2	BASE_EXPORT size_t strlcpy(char* dst, const char* src, size_t dst_size); BASE_EXPORT size_t wcslcpy(wchar_t* dst, const wchar_t* src, size_t dst_size);

大小写转换

// Converts the given string to it's ASCII-lowercase equivalent.

BASE_EXPORT std::string ToLowerASCII(StringPiece str);

BASE_EXPORT string16 ToLowerASCII(StringPiece16 str);

// Converts the given string to it's ASCII-uppercase equivalent.

BASE_EXPORT std::string ToUpperASCII(StringPiece str);

BASE_EXPORT string16 ToUpperASCII(StringPiece16 str);

比较

// Like strcasecmp for case-insensitive ASCII characters only. Returns:

// -1 (a < b)

// 0 (a == b)

// 1 (a > b)

// (unlike strcasecmp which can return values greater or less than 1/-1). For

// full Unicode support, use base::i18n::ToLower or base::i18h::FoldCase

// and then just call the normal string operators on the result.

BASE_EXPORT int CompareCaseInsensitiveASCII(StringPiece a, StringPiece b);

BASE_EXPORT int CompareCaseInsensitiveASCII(StringPiece16 a, StringPiece16 b);

// Equality for ASCII case-insensitive comparisons. For full Unicode support,

// use base::i18n::ToLower or base::i18h::FoldCase and then compare with either

// == or !=.

BASE_EXPORT bool EqualsCaseInsensitiveASCII(StringPiece a, StringPiece b);

BASE_EXPORT bool EqualsCaseInsensitiveASCII(StringPiece16 a, StringPiece16 b);

构造空串

1 2	BASE_EXPORT const std::string& EmptyString(); BASE_EXPORT const string16& EmptyString16();

删除字符

BASE_EXPORT bool RemoveChars(const string16& input,

StringPiece16 remove_chars,

string16* output);

BASE_EXPORT bool RemoveChars(const std::string& input,

StringPiece remove_chars,

std::string* output);

替换字符

BASE_EXPORT bool ReplaceChars(const string16& input,

StringPiece16 replace_chars,

const string16& replace_with,

string16* output);

BASE_EXPORT bool ReplaceChars(const std::string& input,

StringPiece replace_chars,

const std::string& replace_with,

std::string* output);

删除匹配字符

BASE_EXPORT bool TrimString(StringPiece16 input,

StringPiece16 trim_chars,

string16* output);

BASE_EXPORT bool TrimString(StringPiece input,

StringPiece trim_chars,

std::string* output);

BASE_EXPORT StringPiece16 TrimString(StringPiece16 input,

StringPiece16 trim_chars,

TrimPositions positions);

BASE_EXPORT StringPiece TrimString(StringPiece input,

StringPiece trim_chars,

TrimPositions positions);

删除两端空格

BASE_EXPORT TrimPositions TrimWhitespace(StringPiece16 input,

TrimPositions positions,

string16* output);

BASE_EXPORT StringPiece16 TrimWhitespace(StringPiece16 input,

TrimPositions positions);

BASE_EXPORT TrimPositions TrimWhitespaceASCII(StringPiece input,

TrimPositions positions,

std::string* output);

BASE_EXPORT StringPiece TrimWhitespaceASCII(StringPiece input,

TrimPositions positions);

空格处理

删除前后空格
trim_sequences_with_line_breaks为true，其他任何空格去掉包含CR或LF的序列。
将其他空格序列都转换为单个空格

BASE_EXPORT string16 CollapseWhitespace(

const string16& text,

bool trim_sequences_with_line_breaks);

BASE_EXPORT std::string CollapseWhitespaceASCII(

const std::string& text,

bool trim_sequences_with_line_breaks);

// Returns true if |input| is empty or contains only characters found in

// |characters|.

BASE_EXPORT bool ContainsOnlyChars(StringPiece input, StringPiece characters);

BASE_EXPORT bool ContainsOnlyChars(StringPiece16 input,

StringPiece16 characters);

编码判断

BASE_EXPORT bool IsStringUTF8(StringPiece str);

BASE_EXPORT bool IsStringASCII(StringPiece str);

BASE_EXPORT bool IsStringASCII(StringPiece16 str);

BASE_EXPORT bool IsStringASCII(WStringPiece str);

ASCII判断

BASE_EXPORT bool LowerCaseEqualsASCII(StringPiece str,

StringPiece lowecase_ascii);

BASE_EXPORT bool LowerCaseEqualsASCII(StringPiece16 str,

StringPiece lowecase_ascii);

BASE_EXPORT bool EqualsASCII(StringPiece16 str, StringPiece ascii);

16进制字符转数值

1 2	// Assumes the input is a valid hex character. DCHECKs in debug builds if not. BASE_EXPORT char HexDigitToInt(wchar_t c);

unicode空格

1 2	// Returns true if it's a Unicode whitespace character. BASE_EXPORT bool IsUnicodeWhitespace(wchar_t c);

带分隔符拼接字符串

BASE_EXPORT std::string JoinString(const std::vector<std::string>& parts,

StringPiece separator);

BASE_EXPORT string16 JoinString(const std::vector<string16>& parts,

StringPiece16 separator);

BASE_EXPORT std::string JoinString(const std::vector<StringPiece>& parts,

StringPiece separator);

BASE_EXPORT string16 JoinString(const std::vector<StringPiece16>& parts,

StringPiece16 separator);

// Explicit initializer_list overloads are required to break ambiguity when used

// with a literal initializer list (otherwise the compiler would not be able to

// decide between the string and StringPiece overloads).

BASE_EXPORT std::string JoinString(std::initializer_list<StringPiece> parts,

StringPiece separator);

BASE_EXPORT string16 JoinString(std::initializer_list<StringPiece16> parts,

StringPiece16 separator);

string16

base::

BASE_EXPORT int c16memcmp(const char16* s1, const char16* s2, size_t n);

BASE_EXPORT size_t c16len(const char16* s);

BASE_EXPORT const char16* c16memchr(const char16* s, char16 c, size_t n);

BASE_EXPORT char16* c16memmove(char16* s1, const char16* s2, size_t n);

BASE_EXPORT char16* c16memcpy(char16* s1, const char16* s2, size_t n);

BASE_EXPORT char16* c16memset(char16* s, char16 c, size_t n);

sys_string_conversions

base::

宽字节-UTF8

1 2	BASE_EXPORT std::string SysWideToUTF8(const std::wstring& wide); BASE_EXPORT std::wstring SysUTF8ToWide(StringPiece utf8);

宽字节-系统多字节

// Converts between wide and the system multi-byte representations of a string.

// DANGER: This will lose information and can change (on Windows, this can

// change between reboots).

BASE_EXPORT std::string SysWideToNativeMB(const std::wstring& wide);

BASE_EXPORT std::wstring SysNativeMBToWide(StringPiece native_mb);

8-bits-宽字节

// Converts between 8-bit and wide strings, using the given code page. The

// code page identifier is one accepted by the Windows function

// MultiByteToWideChar().

BASE_EXPORT std::wstring SysMultiByteToWide(StringPiece mb, uint32_t code_page);

BASE_EXPORT std::string SysWideToMultiByte(const std::wstring& wide,

uint32_t code_page);

utf_string_conversions

UTF8-UTF16-UTF32转换

BASE_EXPORT bool WideToUTF8(const wchar_t* src, size_t src_len,

std::string* output);

BASE_EXPORT std::string WideToUTF8(WStringPiece wide);

BASE_EXPORT bool UTF8ToWide(const char* src, size_t src_len,

std::wstring* output);

BASE_EXPORT std::wstring UTF8ToWide(StringPiece utf8);

BASE_EXPORT bool WideToUTF16(const wchar_t* src, size_t src_len,

string16* output);

BASE_EXPORT string16 WideToUTF16(WStringPiece wide);

BASE_EXPORT bool UTF16ToWide(const char16* src, size_t src_len,

std::wstring* output);

BASE_EXPORT std::wstring UTF16ToWide(StringPiece16 utf16);

BASE_EXPORT bool UTF8ToUTF16(const char* src, size_t src_len, string16* output);

BASE_EXPORT string16 UTF8ToUTF16(StringPiece utf8);

BASE_EXPORT bool UTF16ToUTF8(const char16* src, size_t src_len,

std::string* output);

BASE_EXPORT std::string UTF16ToUTF8(StringPiece16 utf16);

// This converts an ASCII string, typically a hardcoded constant, to a UTF16

// string.

BASE_EXPORT string16 ASCIIToUTF16(StringPiece ascii);

// Converts to 7-bit ASCII by truncating. The result must be known to be ASCII

// beforehand.

BASE_EXPORT std::string UTF16ToASCII(StringPiece16 utf16);

string_piece_forward
strcat
Strcat
StrAppend
string_number_conversions
Number -> string
String -> number
16进制相关的转换
string_piece
string_split
分割类型
方法
string_util
拷贝
大小写转换
比较
构造空串
删除字符
替换字符
删除匹配字符
删除两端空格
空格处理
编码判断
ASCII判断
16进制字符转数值
unicode空格
带分隔符拼接字符串
string16
sys_string_conversions
宽字节-UTF8
宽字节-系统多字节
8-bits-宽字节
utf_string_conversions
UTF8-UTF16-UTF32转换

本文为原创文章，版权归Aet所有，欢迎分享本文，转载请保留出处！

Bingliaolong 关注：0 粉丝：0 最后编辑于：2021-11-20

Everything will be better.

一	二	三	四	五	六	日
1	2	3	4	5	6	7
8	9	10	11	12	13	14
15	16	17	18	19	20	21
22	23	24	25	26	27	28
29	30	31

string_piece_forward

strcat

Strcat

StrAppend

string_number_conversions

Number -> string

String -> number

16进制相关的转换

string_piece

string_split

分割类型

方法

string_util

拷贝

大小写转换

比较

构造空串

删除字符

替换字符

删除匹配字符

删除两端空格

空格处理

编码判断

ASCII判断

16进制字符转数值

unicode空格

带分隔符拼接字符串

string16

sys_string_conversions

宽字节-UTF8

宽字节-系统多字节

8-bits-宽字节

utf_string_conversions

UTF8-UTF16-UTF32转换

你可能也喜欢

热评文章

发表评论

标签云集