C++ string::GetLength方法代码示例

bool IsRootPath(const string &Path)
{
	size_t PathRootLen = GetPathRootLength(Path);

	if (Path.GetLength() == PathRootLen)
		return true;

	if (Path.GetLength() == PathRootLen + 1 && IsSlash(Path[Path.GetLength() - 1]))
		return true;

	return false;
}

bool History::GetSimilar(string &strStr, int LastCmdPartLength, bool bAppend)
{
	int Length=(int)strStr.GetLength();

	if (LastCmdPartLength!=-1 && LastCmdPartLength<Length)
		Length=LastCmdPartLength;

	if (LastCmdPartLength==-1)
	{
		ResetPosition();
	}

	for (HistoryRecord *HistoryItem=HistoryList.Prev(CurrentItem); HistoryItem != CurrentItem; HistoryItem=HistoryList.Prev(HistoryItem))
	{
		if (!HistoryItem)
			continue;

		if (!StrCmpNI(strStr,HistoryItem->strName,Length) && StrCmp(strStr,HistoryItem->strName))
		{
			if (bAppend)
				strStr += &HistoryItem->strName[Length];
			else
				strStr = HistoryItem->strName;

			CurrentItem = HistoryItem;
			return true;
		}
	}

	return false;
}

BOOL AddEndSlash(string &strPath, wchar_t TypeSlash)
{
	wchar_t *lpwszPath = strPath.GetBuffer(strPath.GetLength()+2);
	BOOL Result = AddEndSlash(lpwszPath, TypeSlash);
	strPath.ReleaseBuffer();
	return Result;
}

int DizList::GetDizPosEx(const string& Name, const string& ShortName, int *TextPos)
{
	int DizPos=GetDizPos(Name,TextPos);

	if (DizPos==-1)
		DizPos=GetDizPos(ShortName,TextPos);

	//если файл описаний был в OEM/ANSI то имена файлов могут не совпадать с юникодными
	if (DizPos==-1 && !IsUnicodeOrUtfCodePage(OrigCodePage) && OrigCodePage!=CP_DEFAULT)
	{
		size_t len = Name.GetLength();
		char *tmp = (char *)xf_realloc_nomove(AnsiBuf, len+1);

		if (!tmp)
			return -1;

		AnsiBuf = tmp;
		WideCharToMultiByte(OrigCodePage, 0, Name, static_cast<int>(len), AnsiBuf, static_cast<int>(len), nullptr, nullptr);
		AnsiBuf[len]=0;
		string strRecoded(AnsiBuf, OrigCodePage);

		if (strRecoded==Name)
			return -1;

		return GetDizPos(strRecoded,TextPos);
	}

	return DizPos;
}

void QuoteSpaceOnly(string& strSrc)
{
	TCHAR* lpBuffer = strSrc.GetBuffer(strSrc.GetLength()+5);

	FSF.QuoteSpaceOnly(lpBuffer);

	strSrc.ReleaseBuffer();
}

void farQuoteSpaceOnly(string& strStr)
{
	TCHAR* pBuffer = strStr.GetBuffer(strStr.GetLength()+2);

	FSF.QuoteSpaceOnly(pBuffer);

	strStr.ReleaseBuffer();
}

void UnquoteExternal(string &strStr)
{
	size_t len = strStr.GetLength();

	if (len > 1 && strStr.At(0) == L'\"' && strStr.At(len-1) == L'\"')
	{
		strStr.SetLength(len-1);
		strStr.LShift(1);
	}
}

int GetRegKey(const wchar_t *Key,const wchar_t *ValueName,string &strValueData,const wchar_t *Default,DWORD *pType)
{
	int ExitCode=!ERROR_SUCCESS;
	HKEY hKey=OpenRegKey(Key);

	if (hKey) // надобно проверить!
	{
		DWORD Type,QueryDataSize=0;

		if ((ExitCode = RegQueryValueEx(
		                    hKey,
		                    ValueName,
		                    0,
		                    &Type,
		                    nullptr,
		                    &QueryDataSize
		                )) == ERROR_SUCCESS)
		{
			wchar_t *TempBuffer = strValueData.GetBuffer(QueryDataSize/sizeof(wchar_t)+1);  // ...то выделим сколько надо
			ExitCode = RegQueryValueEx(hKey,ValueName,0,&Type,(unsigned char *)TempBuffer,&QueryDataSize);
			strValueData.ReleaseBuffer(QueryDataSize/sizeof(wchar_t));

			if (strValueData.GetLength() > 0 && !strValueData.At(strValueData.GetLength()-1))
				strValueData.SetLength(strValueData.GetLength()-1);
		}

		if (pType)
			*pType=Type;

		CloseRegKey(hKey);
	}

	if (ExitCode!=ERROR_SUCCESS)
	{
		strValueData = Default;
		return FALSE;
	}

	return TRUE;
}

bool FindLastSlash(size_t &Pos, const string &Str)
{
	for (size_t p = Str.GetLength(); p > 0; p--)
	{
		if (IsSlash(Str[p - 1]))
		{
			Pos = p - 1;
			return true;
		}
	}

	return false;
}

bool FindSlash(size_t &Pos, const string &Str, size_t StartPos)
{
	for (size_t p = StartPos; p < Str.GetLength(); p++)
	{
		if (IsSlash(Str[p]))
		{
			Pos = p;
			return true;
		}
	}

	return false;
}

string& WINAPI RemoveTrailingSpaces(string &strStr)
{
	if (strStr.IsEmpty())
		return strStr;

	const wchar_t *Str = strStr;
	const wchar_t *ChPtr = Str + strStr.GetLength() - 1;

	for (; ChPtr >= Str && (IsSpace(*ChPtr) || IsEol(*ChPtr)); ChPtr--)
		;

	strStr.SetLength(ChPtr < Str ? 0 : ChPtr-Str+1);
	return strStr;
}

string ReplaceBrackets(const string& SearchStr,const string& ReplaceStr,RegExpMatch* Match,int Count)
{
	string result;
	size_t pos=0,length=ReplaceStr.GetLength();

	while (pos<length)
	{
		bool common=true;

		if (ReplaceStr[pos]=='$')
		{
			++pos;

			if (pos>length) break;

			wchar_t symbol=Upper(ReplaceStr[pos]);
			int index=-1;

			if (symbol>='0'&&symbol<='9')
			{
				index=symbol-'0';
			}
			else if (symbol>='A'&&symbol<='Z')
			{
				index=symbol-'A'+10;
			}

			if (index>=0)
			{
				if (index<Count)
				{
					string bracket(SearchStr.CPtr()+Match[index].start,Match[index].end-Match[index].start);
					result+=bracket;
				}

				common=false;
			}
		}

		if (common)
		{
			result+=ReplaceStr[pos];
		}

		++pos;
	}

	return result;
}

/* $ 02.02.2001 IS
   Заменяет пробелами непечатные символы в строке. В настоящий момент
   обрабатываются только cr и lf.
*/
string& WINAPI RemoveUnprintableCharacters(string &strStr)
{
	wchar_t *p = strStr.GetBuffer();

	while (*p)
	{
		if (IsEol(*p))
			*p=L' ';

		p++;
	}

	strStr.ReleaseBuffer(strStr.GetLength());
	return RemoveExternalSpaces(strStr);
}

string ExtractFileName(const string &Path)
{
	size_t p;

	if (FindLastSlash(p, Path))
		p++;
	else
		p = 0;

	size_t PathRootLen = GetPathRootLength(Path);

	if (p <= PathRootLen && PathRootLen)
		return string();

	return string(Path.CPtr() + p, Path.GetLength() - p);
}

// Заменить в строке Str Count вхождений подстроки FindStr на подстроку ReplStr
// Если Count < 0 - заменять "до полной победы"
// Return - количество замен
int ReplaceStrings(string &strStr,const wchar_t *FindStr,const wchar_t *ReplStr,int Count,BOOL IgnoreCase)
{
	const int LenFindStr=StrLength(FindStr);
	if ( !LenFindStr || !Count )
		return 0;
	const int LenReplStr=StrLength(ReplStr);
	size_t L=strStr.GetLength();

	const int Delta = LenReplStr-LenFindStr;
	const int AllocDelta = Delta > 0 ? Delta*10 : 0;

	size_t I=0;
	int J=0;
	while (I+LenFindStr <= L)
	{
		int Res=IgnoreCase?StrCmpNI(&strStr[I], FindStr, LenFindStr):StrCmpN(&strStr[I], FindStr, LenFindStr);

		if (!Res)
		{
			wchar_t *Str;
			if (L+Delta+1 > strStr.GetSize())
				Str = strStr.GetBuffer(L+AllocDelta);
			else
				Str = strStr.GetBuffer();

			if (Delta > 0)
				wmemmove(Str+I+Delta,Str+I,L-I+1);
			else if (Delta < 0)
				wmemmove(Str+I,Str+I-Delta,L-I+Delta+1);

			wmemcpy(Str+I,ReplStr,LenReplStr);
			I += LenReplStr;

			L+=Delta;
			strStr.ReleaseBuffer(L);

			if (++J == Count && Count > 0)
				break;
		}
		else
		{
			I++;
		}
	}

	return J;
}