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

	void D3DFontObject9::DrawText(const boost::shared_ptr<const ID3DSprite> &pSprite,
		std::wstring textString, RECT &screenRect, uint32 flags, const D3DXCOLOR &color) const {
		if (m_d3dxFont != nullptr) {
			CComPtr<ID3DXSprite> pD3DXSprite = nullptr;
			const auto pSprite9 = boost::dynamic_pointer_cast<const D3DSprite9>(pSprite);
			if (pSprite9 != nullptr)
				pD3DXSprite = pSprite9->GetD3DXSprite();

			// has trailing whitespace?
			// todo: proper fix for multiline + hcentered
			uint32 length = textString.length();
			if (length != 0 && textString.back() == L' ')
			{
				// this hack only works for single line align
				if ((flags & DT_SINGLELINE) == DT_SINGLELINE) {
					flags &= ~(DT_CENTER | DT_VCENTER | DT_RIGHT | DT_BOTTOM);
					screenRect = GetTextExtent(textString, screenRect, flags);
				}
				else
					textString.back() = 0xA0; // "non breaking space"
			}

			m_d3dxFont->DrawTextW(pD3DXSprite, textString.data(), length, &screenRect, flags, color);
		}
	}

bool CServerPath::SegmentizeAddSegment(std::wstring & segment, tSegmentList& segments, bool& append)
{
	if (traits[m_type].has_dots) {
		if (segment == L".") {
			return true;
		}
		else if (segment == L"..") {
			if (segments.empty()) {
				return false;
			}
			else {
				segments.pop_back();
				return true;
			}
		}
	}

	bool append_next = false;
	if (!segment.empty() && traits[m_type].separatorEscape && segment.back() == traits[m_type].separatorEscape) {
		append_next = true;
		segment[segment.size() - 1] = traits[m_type].separators[0];
	}

	if (append) {
		segments.back() += segment;
	}
	else {
		segments.push_back(std::move(segment));
	}

	append = append_next;

	return true;
}

 void formatPath(std::wstring & fname)
 {
     if(fname.empty()) return;
     
     std::replace(fname.begin(), fname.end(), L'\\', L'/');
     if(fname.back() != L'/') fname += L'/';
 }

std::vector<std::wstring> GetFileList(const std::wstring& pattern, const bool fullPaths)
{
	const std::wstring directory = (fullPaths ? GetDirPart(pattern) : L"");

	// may not pass an empty string to FindFirstFileEx
	UIETWASSERT(pattern.length() > 0);

	// string passed to FindFirstFileEx must not end in a backslash
	UIETWASSERT(pattern.back() != L'\\');

	WIN32_FIND_DATA findData;
	HANDLE hFindFile = ::FindFirstFileExW(pattern.c_str(), FindExInfoBasic,
				&findData, FindExSearchNameMatch, NULL, 0);

	std::vector<std::wstring> result;
	if (hFindFile == INVALID_HANDLE_VALUE)
	{
		// If there are NO matching files, then FindFirstFileExW returns
		// INVALID_HANDLE_VALUE and the last error is ERROR_FILE_NOT_FOUND.
		UIETWASSERT(::GetLastError() == ERROR_FILE_NOT_FOUND);
		return result;
	}
	do
	{
		result.emplace_back(directory + findData.cFileName);
	} while (::FindNextFileW(hFindFile, &findData));

	UIETWASSERT(::GetLastError() == ERROR_NO_MORE_FILES);
	ATLVERIFY(::FindClose(hFindFile));
	return result;
}

	std::list<std::wstring> EnumerateFiles(std::wstring path)
	{
		std::list<std::wstring> result;
		if (path.empty())
			return result;

#if defined(_WIN32)
		HANDLE dir;
		WIN32_FIND_DATAW data;

		// Rewrite slashes for better compatibility.
		for (auto& c: path)
		{
			if (c == L'/')
				c = L'\\';
		}

		// Appending '\*' handles the case of querying a disk root.
		if (path.back() != L'\\')
			path += L'\\';
		path += L'*';

		if ((dir = ::FindFirstFileW(path.c_str(), &data)) != INVALID_HANDLE_VALUE)
		{
			BOOL rc = TRUE;
			do
			{
				if (!(data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
					result.push_back(data.cFileName);
				rc = ::FindNextFileW(dir, &data);
			}
			while (rc);
			::FindClose(dir);
		}
#else
		DIR* dir;

		std::string u8path = UTF8Encoding().Convert(path);
		if (u8path.empty() || u8path.back() != '/')
			u8path += '/';

		if ((dir = ::opendir(u8path.c_str())) != nullptr)
		{
			struct dirent ent, *pent = &ent;
			while (::readdir_r(dir, pent, &pent) == 0 && pent != nullptr)
			{
				struct stat st;
				if (::stat((u8path + pent->d_name).c_str(), &st) == 0 && (st.st_mode & S_IFREG))
				{
					result.push_back(UTF8Encoding().Convert(pent->d_name));
				}
			}
			::closedir(dir);
		}
#endif
		return result;
	}

	RECT D3DFontObject9::GetTextExtent(std::wstring textString, RECT rect, uint32 flags) const {
		if (m_d3dxFont != nullptr) {
			uint32 length = textString.length();
			bool trailingSpace = (length != 0 && textString.back() == L' ');
			if (trailingSpace)
				textString.back() = L'.';

			m_d3dxFont->DrawTextW(nullptr, textString.data(), length, &rect, flags | DT_CALCRECT, 0);

			// adjust the rectangle...
			if (trailingSpace) {
				rect.right += m_spaceExtent.x;
				rect.right -= m_pointExtent.x;
			}
		}

		return rect;
	}

int DeleteFolder(std::wstring path) {
  if (path.back() == '\\')
    path.pop_back();

  path.push_back('\0');

  SHFILEOPSTRUCT fos = {0};
  fos.wFunc = FO_DELETE;
  fos.pFrom = path.c_str();
  fos.fFlags = FOF_NOCONFIRMATION | FOF_NOERRORUI | FOF_SILENT;

  return SHFileOperation(&fos);
}

int CPython::ExecFunc(const std::vector<std::wstring> &argv, std::wstring &err, HANDLE hfile)
{
	std::vector<std::wstring>::const_iterator itr, eitr; 
	itr = argv.cbegin(); eitr = argv.cend(); err = *itr; 
	if (argv.size() <= 0) {
		err = text("No python command function found"); return 1;
	}
	err.push_back(text('('));
	for (++itr; itr != eitr; ++itr) { 
		err.append(*itr); err.push_back(text(',')); 
	} 
	if (err.back() == text(',')) err.pop_back(); 
	err.push_back(text(')')); 
	Addtolist(1,1,text("Execute Function: %s"),err.c_str());

	int id = 0; FILE *pfile = nullptr; DWORD count = 0;
	PyObject *poldout, *polderr, *pnewout, *pnewerr; 
	if (DuplicateHandle (
		GetCurrentProcess(), hfile, GetCurrentProcess(), &hfile, 
		0, false, DUPLICATE_SAME_ACCESS
	)) {
		id = open_osfhandle((intptr_t)hfile, _O_WRONLY); 
		pfile = fdopen(id,"w"); setvbuf(pfile,nullptr,_IONBF,1024);
		poldout = PySys_GetObject("stdout");
		polderr = PySys_GetObject("stderr");
		pnewout = PyFile_FromFile(pfile, "logger", "w", nullptr);
		pnewerr = PyFile_FromFile(pfile, "logger", "w", nullptr);
		PySys_SetObject("stdout", pnewout);
		PySys_SetObject("stderr", pnewerr);
	} else poldout = polderr = pnewout = pnewerr = nullptr;

	std::wstring_convert<std::codecvt_utf8_utf16<wchar>> cvt; 
	std::string str = cvt.to_bytes(err); 
	std::size_t pos = str.find(text('.')); 
	if (pos != std::string::npos) { 
		std::string mod = str.substr(0, pos); 
		PyObject* dest = PyImport_ImportModule(mod.c_str()); 
		PyObject* main = PyImport_AddModule("__main__"); 
		PyObject_SetAttrString(main, mod.c_str(), dest); 
	} 
	str.insert(0, "print ");
	int irslt = PyRun_SimpleString(str.c_str());
	if (irslt != 0) err = text("Internal error that PyRun_SimpleString fail"); 
	else err = text("Execute python function successfully .."); 

	if (pnewout != nullptr) PySys_SetObject("stdout", poldout);
	if (pnewerr != nullptr) PySys_SetObject("stderr", polderr);
	if (pfile != nullptr) fclose(pfile); return irslt;
}

bool DialogInstall::ExtractCurrentFile(const std::wstring& fileName)
{
	// Some archives don't explicity list directories, so create them recursively
	if (!CreateDirectoryRecursive(fileName))
	{
		return false;
	}

	if (fileName.back() == L'\\')
	{
		// Nothing left to do
		return true;
	}

	if (unzOpenCurrentFile(m_PackageUnzFile) != UNZ_OK)
	{
		return false;
	}

	HANDLE hFile = CreateFile(fileName.c_str(), GENERIC_WRITE, 0, nullptr, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, nullptr);
	if (hFile == INVALID_HANDLE_VALUE)
	{
		return false;
	}

	int read;
	do
	{
		BYTE buffer[16384];
		DWORD written;
		read = unzReadCurrentFile(m_PackageUnzFile, buffer, 16384);
		if (read < 0 || !WriteFile(hFile, (LPCVOID)buffer, read, &written, nullptr) || read != written)
		{
			read = UNZ_ERRNO;
			break;
		}
	}
	while (read != UNZ_EOF);

	CloseHandle(hFile);

	return unzCloseCurrentFile(m_PackageUnzFile) == UNZ_OK && read == UNZ_EOF;
}

bool Ends_With(std::wstring const& str, wchar_t const& end_part){
	if (!str.empty()){
		return str.back() == end_part;
	}
	return false;
}