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

void ConvertUncode( const string &sString, wstring &wsString )
{
	int nSize = MultiByteToWideChar( CP_ACP, 0, sString.c_str(), -1, NULL, 0 );
	nSize --;
	wsString.resize( nSize );
	MultiByteToWideChar( CP_ACP, 0, sString.c_str(), -1, &wsString[0], nSize );
}

void ErasePunctuation(wstring& str, bool keep_trailing) {
  auto rlast = str.rbegin();

  if (keep_trailing)
    rlast = std::find_if(str.rbegin(), str.rend(),
        [](wchar_t c) -> bool {
          return !(c == L'!' || // "Hayate no Gotoku!", "K-ON!"...
                   c == L'+' || // "Needless+"
                   c == L'\''); // "Gintama'"
        });

  auto it = std::remove_if(str.begin(), rlast.base(),
      [](int c) -> bool {
        // Control codes, white-space and punctuation characters
        if (c <= 255 && !isalnum(c))
          return true;
        // Unicode stars, hearts, notes, etc. (0x2000-0x2767)
        if (c > 8192 && c < 10087)
          return true;
        // Valid character
        return false;
      });

  if (keep_trailing)
    std::copy(rlast.base(), str.end(), it);

  str.resize(str.size() - (rlast.base() - it));
}

wstring GetFileWithoutExtension(wstring str) {
  size_t pos = str.find_last_of(L".");

  if (pos != wstring::npos)
    str.resize(pos);

  return str;
}

	void BinReader::_serialize( wstring& nValue, const wchar_t * nName, const wchar_t * nOptimal )
	{
		__u16 count_ = 0;
		__i8 value_ = 0;
		mStream.read((char *)(&count_), sizeof(__u16));
		nValue.resize(count_);
		mStream.read((char *)(&nValue[0]), sizeof(wchar_t) * count_);
	}

void
GUID2String( const GUID &guid, wstring &str )
{
	str.resize( 36 );

	swprintf_s( (wchar_t*)str.data(), 37, _T("%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X"),
				guid.Data1, guid.Data2, guid.Data3,
				guid.Data4[0], guid.Data4[1], guid.Data4[2], guid.Data4[3],
				guid.Data4[4], guid.Data4[5], guid.Data4[6], guid.Data4[7] );
}

bool IO_CharDecoder::ReadUNICODE(IO_InputDataStream* stream, wstring& text)
{
	if(stream == NULL)
	{
		return false;
	}

	size_t length = 0;

	text.resize(IO_CHAR_BUFFER_SIZE);

	while(true)
	{
		int ch1 = stream->ReadByte() & 0xff;
		int ch2 = stream->ReadByte() & 0xff;
		int ch = ch1 | (ch2 << 8);

		if(length >= text.max_size())
		{
			text.resize(text.max_size() * 2);
		}

		if(ch == 0)
		{
			break;
		}

		if(ch == '\r')
		{
			stream->Skip(2);
		}

		if(ch == '\n')
		{
			break;
		}

		text[length++] = (wchar_t)ch;
	}

	return true;
}

void EraseRight(wstring& str1, const wstring& str2, bool case_insensitive) {
  if (str1.length() < str2.length())
    return;

  if (case_insensitive) {
    if (!std::equal(str2.begin(), str2.end(), str1.end() - str2.length(),
                    &IsCharsEqual))
      return;
  } else {
    if (!std::equal(str2.begin(), str2.end(), str1.end() - str2.length()))
      return;
  }

  str1.resize(str1.length() - str2.length());
}

// determine the directory for a given pathname
// (wstring only for now; feel free to make this a template if needed)
/*static*/ wstring File::DirectoryPathOf(wstring path)
{
#ifdef _WIN32
    // Win32 accepts forward slashes, but it seems that PathRemoveFileSpec() does not
    // TODO:
    // "PathCchCanonicalize does the / to \ conversion as a part of the canonicalization, it's
    // probably a good idea to do that anyway since I suspect that the '..' characters might
    // confuse the other PathCch functions" [Larry Osterman]
    // "Consider GetFullPathName both for canonicalization and last element finding." [Jay Krell]
    path = msra::strfun::ReplaceAll<wstring>(path, L"/", L"\\");

    HRESULT hr;
    if (IsWindows8OrGreater()) // PathCchRemoveFileSpec() only available on Windows 8+
    {
        typedef HRESULT(*PathCchRemoveFileSpecProc)(_Inout_updates_(_Inexpressible_(cchPath)) PWSTR, _In_ size_t);
        HINSTANCE hinstLib = LoadLibrary(TEXT("api-ms-win-core-path-l1-1-0.dll"));
        if (hinstLib == nullptr)
            RuntimeError("DirectoryPathOf: LoadLibrary() unexpectedly failed.");
        PathCchRemoveFileSpecProc PathCchRemoveFileSpec = reinterpret_cast<PathCchRemoveFileSpecProc>(GetProcAddress(hinstLib, "PathCchRemoveFileSpec"));
        if (!PathCchRemoveFileSpec)
            RuntimeError("DirectoryPathOf: GetProcAddress() unexpectedly failed.");

        // this is the actual function call we care about
        hr = PathCchRemoveFileSpec(&path[0], path.size());

        FreeLibrary(hinstLib);
    }
    else // on Windows 7-, use older PathRemoveFileSpec() instead
        hr = PathRemoveFileSpec(&path[0]) ? S_OK : S_FALSE;

    if (hr == S_OK) // done
        path.resize(wcslen(&path[0]));
    else if (hr == S_FALSE) // nothing to remove: use .
        path = L".";
    else
        RuntimeError("DirectoryPathOf: Path(Cch)RemoveFileSpec() unexpectedly failed with 0x%08x.", (unsigned int)hr);
#else
    auto pos = path.find_last_of(L"/");
    if (pos != path.npos)
        path.erase(pos);
    else // if no directory path at all, use current directory
        return L".";
#endif
    return path;
}

static void do_log(int log_level, const char *msg, va_list args, void *param)
{
	fstream &logFile = *static_cast<fstream*>(param);
	char str[4096];

#ifndef _WIN32
	va_list args2;
	va_copy(args2, args);
#endif

	vsnprintf(str, 4095, msg, args);

#ifdef _WIN32
	if (IsDebuggerPresent()) {
		int wNum = MultiByteToWideChar(CP_UTF8, 0, str, -1, NULL, 0);
		if (wNum > 1) {
			static wstring wide_buf;
			static mutex wide_mutex;

			lock_guard<mutex> lock(wide_mutex);
			wide_buf.reserve(wNum + 1);
			wide_buf.resize(wNum - 1);
			MultiByteToWideChar(CP_UTF8, 0, str, -1, &wide_buf[0],
					wNum);
			wide_buf.push_back('\n');

			OutputDebugStringW(wide_buf.c_str());
		}
	}
#else
	def_log_handler(log_level, msg, args2, nullptr);
#endif

	if (too_many_repeated_entries(logFile, msg, str))
		return;

	if (log_level <= LOG_INFO || log_verbose)
		LogStringChunk(logFile, str);

#if defined(_WIN32) && defined(OBS_DEBUGBREAK_ON_ERROR)
	if (log_level <= LOG_ERROR && IsDebuggerPresent())
		__debugbreak();
#endif
}

void MediaPlayers::EditTitle(wstring& str, int player_index) {
    if (str.empty() || items[player_index].edits.empty()) return;

    for (unsigned int i = 0; i < items[player_index].edits.size(); i++) {
        switch (items[player_index].edits[i].mode) {
        // Erase
        case 1: {
            Replace(str, items[player_index].edits[i].value, L"", false, true);
            break;
        }
        // Cut right side
        case 2: {
            int pos = InStr(str, items[player_index].edits[i].value, 0);
            if (pos > -1) str.resize(pos);
            break;
        }
        }
    }

    TrimRight(str, L" -");
}

void ConfigHelper::ExpandDotDotDot(wstring& featPath, const wstring& scpPath, wstring& scpDirCached)
{
    wstring delim = L"/\\";

    if (scpDirCached.empty())
    {
        scpDirCached = scpPath;
        wstring tail;
        auto pos = scpDirCached.find_last_of(delim);
        if (pos != wstring::npos)
        {
            tail = scpDirCached.substr(pos + 1);
            scpDirCached.resize(pos);
        }
        if (tail.empty()) // nothing was split off: no dir given, 'dir' contains the filename
            scpDirCached.swap(tail);
    }
    size_t pos = featPath.find(L"...");
    if (pos != featPath.npos)
        featPath = featPath.substr(0, pos) + scpDirCached + featPath.substr(pos + 3);
}

    void utf8ToStdWstring(wstring & dest, const string & src)
    {
      int len = utf8DecodedLength(src);

      dest.resize(len);

      const uint8_t * ptr = (const uint8_t *) src.c_str();

      const uint8_t * sentinel = ptr + src.size();

      int characters = 0;

      // http://en.wikipedia.org/wiki/UTF-8

      while(ptr < sentinel) {
        unsigned c0 = *ptr++;

    unsigned left = sentinel - ptr;

    /* trace("utf8ToStdWstring # 0x%x 0x%x (%c)",
           (int) c0, (int) (c0 & 0xE0), (char) c0); */

        if((c0 & 0x80) == 0)
          dest[characters] = c0;
        else if((c0 & 0xE0) == 0xC0) {
      if(left < 1) {
        error("utf8ToStdWstring # Lacking 1 byte from a UTF8 string");
        return;
      }
          unsigned c1 = *ptr++;
          dest[characters] = (c1 & 0x3F) + ((c0 & 0x1F) << 6);
      /*trace("utf8ToStdWstring # Got 2 = 0x%x (%x %x)",
            (int) dest[characters], c0, c1); */
        }
        else if((c0 & 0xF0) == 0xE0) {
      if(left < 2) {
        error("utf8ToStdWstring # Lacking 2 bytes from a UTF8 string");
        return;
      }

          unsigned c1 = *ptr++;
          unsigned c2 = *ptr++;
          dest[characters] = (c2 & 0x3F) + ((((unsigned) c1) & 0x3F) << 6) +
            ((((unsigned) c0) & 0x0F) << 12);
        }
        else if((c0 & 0xF8) == 0xF0) {
      if(left < 3) {
        error("utf8ToStdWstring # Lacking 3 bytes from a UTF8 string");
        return;
      }

          unsigned c1 = *ptr++;
          unsigned c2 = *ptr++;
          unsigned c3 = *ptr++;
          dest[characters] = (c3 & 0x3) + ((c2 & 0x3F) << 6) +
            ((c1 & 0x3F) << 12) + ((c0 & 0x07) << 18);
        }
    else {
      Radiant::error("utf8ToStdWstring # Bad character 0x%x", (int) c0);
          return;
    }

        characters++;
      }
    }

bool IO_CharDecoder::ReadUTF8(IO_InputDataStream* stream, wstring& text)
{
	if(stream == NULL)
	{
		return false;
	}

	int utflen = stream->ReadShort() & 0xffff;
	vector<char> bytes(utflen);	

	stream->ReadFull(&bytes[0], utflen);
	text.resize(utflen);

	int ch1, ch2, ch3;
	int length = 0;
	int index = 0;

	while(length < utflen)
	{
		ch1 = (int) bytes[length] & 0xff;
		switch(ch1 >> 4)
		{
		case 0: case 1: case 2: case 3: case 4: case 5: case 6: case 7:
			/* 0xxxxxxx*/
			length++;
			text[index++] = (wchar_t)ch1;
			break;
		case 12: case 13:
			/* 110x xxxx   10xx xxxx*/
			length += 2;
			if(length > utflen)
			{
				return false;
			}

			ch2 = (int)bytes[length - 1];
			if((ch2 & 0xC0) != 0x80)
			{
				return false;
			}

			text[index++] = (wchar_t)(((ch1 & 0x1F) << 6) | (ch2 & 0x3F));
			break;
		case 14:
			/* 1110 xxxx  10xx xxxx  10xx xxxx */
			length += 3;
			if(length > utflen)
			{
				return false;
			}

			ch2 = (int)bytes[length - 2];
			ch3 = (int)bytes[length - 1];

			if(((ch2 & 0xC0) != 0x80) || ((ch3 & 0xC0) != 0x80))
			{
				return false;
			}

			text[index++] = (wchar_t)(((ch1 & 0x0F) << 12) | ((ch2 & 0x3F) << 6) | ((ch3 & 0x3F) << 0));
			break;
		default:
			/* 10xx xxxx,  1111 xxxx */
			return false;
		}
	}

	return true;
}

bool BKE_readFile(wstring &result, const wstring &filename)
{
#ifdef _MSC_VER
	ifstream fs(filename, ios_base::binary | ios_base::out);
#else
	char fname[FILENAME_MAX];
	bkpwcstombs(fname, filename.c_str(), FILENAME_MAX);
	ifstream fs(fname, ios_base::binary | ios_base::out);
#endif
	if (!fs.good())
		return false;
	fs.seekg(0, ios_base::end);
	string::size_type s = (string::size_type)fs.tellg();
	fs.seekg(0, ios_base::beg);
	string res;
	res.resize(s + 1);
	fs.read(&res[0], s);
	fs.close();
	if (res.size() >= 2 && (unsigned char)res[0] == 0xFF && (unsigned char)res[1] == 0xFE)
	{
		//Unicode16-LE
		result.clear();
		result.resize(s+1);
#ifdef HAVE_CODECVT
		auto& f = use_facet<codecvt<wchar_t, char16_t, mbstate_t>>(locale());
		mbstate_t mb=mbstate_t();
		const char16_t* from_next;
		wchar_t* to_next;
		f.in(mb, (char16_t*)&res[2], (char16_t*)&res[s], from_next, &result[0], &result[s], to_next);
#else
		utf16toucs4((uint32_t *)&result[0], (uint16_t *)&res[2], s / 2 - 1);
#endif
		return true;
	}
#ifndef WIN32
	mbstowcs(NULL, NULL, 0); // reset the conversion state
#endif
	if (res.size() >= 3 && (unsigned char)res[0] == 0xEF && (unsigned char)res[1] == 0xBB && (unsigned char)res[2] == 0xBF)
	{
		//UTF8-sig
		result.clear();
		result.resize(s + 1);
#ifdef WIN32
		//must use WINAPI on windows
		MultiByteToWideChar(CP_UTF8, 0, (LPCCH)(&res[3]), s - 3, &result[0], s);
#else
		setlocale(LC_ALL, "en_US.UTF-8");
		mbstowcs(&result[0], &res[3], s - 3);
#endif
		return true;
	}
	else
	{
		//use UTF8-unsig in linux and GB2312 in win
		result.resize(s + 1);
#ifdef WIN32
		setlocale(LC_ALL, "zh-CN.GB2312");
#else
		setlocale(LC_ALL, "en_US.UTF-8");
#endif
		mbstowcs(&result[0], &res[0], s);
		return true;
	}
}