C++ wstring::reserve方法代码示例

/*static*/
void WStringCodec::decode(DBusMessageIter& iter, std::wstring& str)
{
   str.clear();

   DBusMessageIter _iter;
   simppl_dbus_message_iter_recurse(&iter, &_iter, DBUS_TYPE_ARRAY);

   int count =
#if DBUS_MAJOR_VERSION == 1 && DBUS_MINOR_VERSION < 9
       dbus_message_iter_get_array_len(&_iter) / sizeof(uint32_t);
#else
       dbus_message_iter_get_element_count(&iter);
#endif
   if (count > 0)
      str.reserve(count);

   while(dbus_message_iter_get_arg_type(&_iter) != 0)
   {
      uint32_t t;
      Codec<uint32_t>::decode(_iter, t);
      str.push_back((wchar_t)t);
   }

   // advance to next element
   dbus_message_iter_next(&iter);
}

void FileReader::ReadRawWString(std::wstring &theWStr, int theNumChars)
{
	theWStr.erase();
	theWStr.reserve(theNumChars);
	for(int i=0; i<theNumChars; i++)
		theWStr += (wchar_t)ReadShort();
}

void load_file2(std::wstring& wstrOut, std::wistream& wistreamIn)
{
	wstrOut.erase();
	//bad() 如果出现错误则返回true 
	if(wistreamIn.bad()) 
		return;
	wstrOut.reserve(wistreamIn.rdbuf()->in_avail());
	wchar_t c;
	//get() 读取字符 
	while(wistreamIn.get(c))
	{
		if(wstrOut.capacity() == wstrOut.size())
			wstrOut.reserve(wstrOut.capacity() * 3);
		wstrOut.append(1, c);
	}
}

	explicit node(nodetype type, wchar_t op = '+', int num = 0)
	{
		t = type;
		l_child = r_child = 0;
		this->op = op;
		this->num = num;
		translist.reserve(10);
	}

const std::wstring& getAlphabet() {

    const wchar_t kMinCharCode = 32, kMaxCharCode = 126;

    static std::wstring alphabet;
    if (alphabet.empty()) {
        alphabet.reserve(kMaxCharCode - kMinCharCode);
        for (wchar_t c = kMinCharCode; c <= kMaxCharCode; ++c) {
            alphabet.push_back(c);
        }
    }
    return alphabet;
}

///-----------------------------------------------------------------------------
///! @brief   TODO enter a description
///! @remark
///-----------------------------------------------------------------------------
void convertToUTF16String(const std::string& str, std::wstring& out)
{
    wchar_t buffer[4096];
    int numberOfWideChars = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, str.c_str(), (int)str.size(), buffer, 0);
    if (numberOfWideChars > 0)
    {
        out.reserve(numberOfWideChars);
        MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, str.c_str(), (int)str.size(), buffer, numberOfWideChars);
        buffer[numberOfWideChars] = 0;
        out = buffer;
    }
    else
    {
        DWORD error = GetLastError();
        HRESULT hr = HRESULT_FROM_WIN32(error);
        MSG_TRACE_CHANNEL("String Conversion Error", "Failed to convert from UTF8 to MB with Hresult: 0x%08x, %s", hr, getLastErrorMessage(error));
    }
}

bool extractWstring(std::istream & sourceFile, std::wstring & result) {
	int stringLengthPrefix = extractInt(sourceFile);
	unsigned char * buff = new unsigned char[2*stringLengthPrefix];
	char16_t oneWchar;

	sourceFile.read((char*)buff, 2*stringLengthPrefix);
	result.clear();
	result.reserve(stringLengthPrefix+1);

	// .CEL files' "Unicode" wide-strings do not actually conform to
	// the Unicode standard. Each wide-byte is big-endian instead
	// of the required little-endian.
	for (int i = 0; i < stringLengthPrefix; i++) {
		oneWchar = buff[i*2] << 8;
		oneWchar += buff[(i+1)*2-1];
		result.append(1, oneWchar);
	}
	delete [] buff;

	return true;
}

/** 
 * Extracts a JSON String as defined by the spec - "<some chars>"
 * Any escaped characters are swapped out for their unescaped values
 *
 * @access protected
 *
 * @param wchar_t** data Pointer to a wchar_t* that contains the JSON text
 * @param std::wstring& str Reference to a std::wstring to receive the extracted string
 *
 * @return bool Returns true on success, false on failure
 */
bool JSON::ExtractString(const wchar_t **data, std::wstring &str)
{
	str = L"";
	
	while (**data != 0)
	{
		// Save the char so we can change it if need be
		wchar_t next_char = **data;
		
		// Escaping something?
		if (next_char == L'\\')
		{
			// Move over the escape char
			(*data)++;
			
			// Deal with the escaped char
			switch (**data)
			{
				case L'"': next_char = L'"'; break;
				case L'\\': next_char = L'\\'; break;
				case L'/': next_char = L'/'; break;
				case L'b': next_char = L'\b'; break;
				case L'f': next_char = L'\f'; break;
				case L'n': next_char = L'\n'; break;
				case L'r': next_char = L'\r'; break;
				case L't': next_char = L'\t'; break;
				case L'u':
				{
					// We need 5 chars (4 hex + the 'u') or its not valid
					if (!simplejson_wcsnlen(*data, 5))
						return false;
					
					// Deal with the chars
					next_char = 0;
					for (int i = 0; i < 4; i++)
					{
						// Do it first to move off the 'u' and leave us on the 
						// final hex digit as we move on by one later on
						(*data)++;
						
						next_char <<= 4;
						
						// Parse the hex digit
						if (**data >= '0' && **data <= '9')
							next_char |= (**data - '0');
						else if (**data >= 'A' && **data <= 'F')
							next_char |= (10 + (**data - 'A'));
						else if (**data >= 'a' && **data <= 'f')
							next_char |= (10 + (**data - 'a'));
						else
						{
							// Invalid hex digit = invalid JSON
							return false;
						}
					}
					break;
				}
				
				// By the spec, only the above cases are allowed
				default:
					return false;
			}
		}
		
		// End of the string?
		else if (next_char == L'"')
		{
			(*data)++;
			str.reserve(); // Remove unused capacity
			return true;
		}
		
		// Disallowed char?
		else if (next_char < L' ' && next_char != L'\t')
		{
			// SPEC Violation: Allow tabs due to real world cases
			return false;
		}
		
		// Add the next char
		str += next_char;
		
		// Move on
		(*data)++;
	}
	
	// If we're here, the string ended incorrectly
	return false;
}

BOOL DownloadWebPageUnicode(std::wstring& page, HINTERNET hInternet, LPCWSTR url)
{
	TRACEST(_T("DownloadWebPageUnicode"), CW2CT(url));
	BOOL bDownloadSuccess = FALSE;
	if (hInternet == NULL)
		return FALSE;
	HINTERNET hFile = InternetOpenUrl(hInternet, url, NULL, 0, INTERNET_FLAG_NO_CACHE_WRITE, 0);
	if (hFile)
	{   
		page.clear();
		DWORD dwSize = 0;
		INT headerCP = 0;//Latin1
		INT pageCP = 0;//Latin1
		INT workingCP = 1252;//Latin1
		if(!HttpQueryInfo(hFile, HTTP_QUERY_RAW_HEADERS_CRLF, 0, &dwSize, 0))
		{
			if (GetLastError()==ERROR_INSUFFICIENT_BUFFER)
			{
				SetLastError(0);
				LPVOID lpOutBuffer = new CHAR[dwSize];
				if (HttpQueryInfo(hFile, HTTP_QUERY_RAW_HEADERS_CRLF, lpOutBuffer, &dwSize, 0))
				{
					//TRACE((LPCTSTR)lpOutBuffer);
					headerCP = GetWindowsCodePageW((LPCTSTR)lpOutBuffer);
				}
				delete[] lpOutBuffer;
			}		
		}

		DWORD pageSize = 0;
		DWORD pageSizeLen = sizeof(pageSize);
		if (::HttpQueryInfo(hFile, HTTP_QUERY_CONTENT_LENGTH, &pageSize, &pageSizeLen, NULL))
		{
			if (pageSize > 0)
				page.reserve(pageSize + 10);
		}
		if (page.capacity() < 1000)
			page.reserve(50000);
		const int bufferSize = 8192;
		const int bufferSizeU = 2 * bufferSize;
		CHAR bf[bufferSize + 1];
		TCHAR bfU[bufferSizeU];
		unsigned long nSize = 0;
		BOOL bReadSuccess = TRUE;
		BOOL bFirstTime = TRUE;
		while(bReadSuccess)
		{
			bReadSuccess = InternetReadFile(hFile, bf, bufferSize, &nSize);
			if (bReadSuccess)
			{
				if (nSize == 0)
				{
					//TRACE(_T("@3 DownloadWebPage. InternetReadFile Finished\r\n"));
					bDownloadSuccess = TRUE;
					break;
				}
				if (bFirstTime)
				{
					bFirstTime = FALSE;
					bf[nSize] = 0;
					pageCP = GetWindowsCodePageA(bf);
					if (headerCP != pageCP)
					{
						TRACE(_T("@3 DownloadWebPage. CodePage Differs (header:%d - page:%d)\r\n"),
							headerCP, pageCP);
					}
					if (pageCP > 0)	//===Choose the Codepage detected from page if available
						workingCP = pageCP;
					else if (headerCP > 0) //===Else select the Codepage detected from headers if available
						workingCP = headerCP;
					//===Otherwise keep the original 1252 (latin 1)
				}
				if (nSize > 0)
				{
					INT bfLen = MultiByteToWideChar(workingCP, 0, bf, nSize, 0, 0);
					if (bfLen < bufferSizeU)
					{
						MultiByteToWideChar(workingCP, 0, bf, nSize, bfU, bfLen);
						page.append(bfU, bfLen);
					}
					else
					{
						TRACE(_T("@1 DownloadWebPageUnicode. Unicode buffer not enough\r\n"));
						bReadSuccess = FALSE;
					}
				}
			}
			else
				HandleInternetError(_T("DownloadWebPageUnicode. InternetReadFile"));
		}
		InternetCloseHandle(hFile);
	}
	else
		HandleInternetError(_T("DownloadWebPageUnicode. InternetOpenUrl"));
	return bDownloadSuccess;
}

void
TextDecoder::Append(std::wstring& str, const uint8_t* bytes, size_t length, CharacterSet charset)
{
	switch (charset)
	{
	case CharacterSet::Unknown:
	case CharacterSet::ISO8859_1:
	case CharacterSet::ASCII:
	{
		str.append(bytes, bytes + length);
		break;
	}
	case CharacterSet::ISO8859_2:
	case CharacterSet::ISO8859_3:
	case CharacterSet::ISO8859_4:
	case CharacterSet::ISO8859_5:
	case CharacterSet::ISO8859_6:
	case CharacterSet::ISO8859_7:
	case CharacterSet::ISO8859_8:
	case CharacterSet::ISO8859_9:
	case CharacterSet::ISO8859_10:
	case CharacterSet::ISO8859_11:
	case CharacterSet::ISO8859_13:
	case CharacterSet::ISO8859_14:
	case CharacterSet::ISO8859_15:
	case CharacterSet::ISO8859_16:
	case CharacterSet::Cp437:
	case CharacterSet::Cp1250:
	case CharacterSet::Cp1251:
	case CharacterSet::Cp1252:
	case CharacterSet::Cp1256:
	{
		str.reserve(str.length() + length);
		for (size_t i = 0; i < length; ++i) {
			uint8_t c = bytes[i];
			if (c < 128)
				str.push_back(c);
			else
				str.push_back(Codecs::SINGLE_BYTE_CODEPAGES[((int)charset - (int)CharacterSet::ISO8859_2) * 128 + c - 128]);
		}
		break;
	}
	case CharacterSet::Shift_JIS:
	{
		std::vector<uint16_t> buf;
		JPTextDecoder::AppendShiftJIS(buf, bytes, length);
		TextUtfEncoding::AppendUtf16(str, buf.data(), buf.size());
		break;
	}
	case CharacterSet::Big5:
	{
		std::vector<uint16_t> buf;
		Big5TextDecoder::AppendBig5(buf, bytes, length);
		TextUtfEncoding::AppendUtf16(str, buf.data(), buf.size());
		break;
	}
	case CharacterSet::GB2312:
	{
		std::vector<uint16_t> buf;
		GBTextDecoder::AppendGB2312(buf, bytes, length);
		TextUtfEncoding::AppendUtf16(str, buf.data(), buf.size());
		break;
	}
	case CharacterSet::GB18030:
	{
		std::vector<uint16_t> buf;
		GBTextDecoder::AppendGB18030(buf, bytes, length);
		TextUtfEncoding::AppendUtf16(str, buf.data(), buf.size());
		break;
	}
	case CharacterSet::EUC_JP:
	{
		std::vector<uint16_t> buf;
		JPTextDecoder::AppendEUCJP(buf, bytes, length);
		TextUtfEncoding::AppendUtf16(str, buf.data(), buf.size());
		break;
	}
	case CharacterSet::EUC_KR:
	{
		std::vector<uint16_t> buf;
		KRTextDecoder::AppendEucKr(buf, bytes, length);
		TextUtfEncoding::AppendUtf16(str, buf.data(), buf.size());
		break;
		break;
	}
	case CharacterSet::UnicodeBig:
	{
		str.reserve(str.length() + length / 2);
		for (size_t i = 0; i + 1 < length; i += 2) {
			str.push_back((static_cast<wchar_t>(bytes[i]) << 8) + bytes[i + 1]);
		}
		break;
	}
	case CharacterSet::UTF8:
	{
		TextUtfEncoding::AppendUtf8(str, bytes, length);
		break;
	}
	default:
		break;
//.........这里部分代码省略.........