bool CTSVNPath::IsValidOnWindows() const
{
if (m_bIsValidOnWindowsKnown)
return m_bIsValidOnWindows;
m_bIsValidOnWindows = true;
EnsureBackslashPathSet();
std::wstring checkPath = m_sBackslashPath;
if (IsUrl())
{
CString uipath = CPathUtils::PathUnescape(GetSVNPathString());
uipath.Replace('/', '\\');
checkPath = uipath.Mid(uipath.Find('\\', uipath.Find(L":\\\\")+3)+1);
}
try
{
// now check for illegal filenames
std::tr1::wregex rx2(L"(\\\\(lpt\\d|com\\d|aux|nul|prn|con)(\\\\|$))|\\*|[^\\\\]\\?|\\||<|>|\\:[^\\\\]", std::tr1::regex_constants::icase | std::tr1::regex_constants::ECMAScript);
if (std::tr1::regex_search(checkPath, rx2, std::tr1::regex_constants::match_default))
m_bIsValidOnWindows = false;
}
catch (std::exception) {}
m_bIsValidOnWindowsKnown = true;
return m_bIsValidOnWindows;
}
bool CTGitPath::IsAdminDir() const
{
if (m_bIsAdminDirKnown)
return m_bIsAdminDir;
EnsureBackslashPathSet();
m_bIsAdminDirKnown = true;
return m_bIsAdminDir;
}
CString CTGitPath::GetRootPathString() const
{
EnsureBackslashPathSet();
CString workingPath = m_sBackslashPath;
LPTSTR pPath = workingPath.GetBuffer(MAX_PATH); // MAX_PATH ok here.
ATLVERIFY(::PathStripToRoot(pPath));
workingPath.ReleaseBuffer();
return workingPath;
}
CString CTSVNPath::GetFileOrDirExtension() const
{
EnsureBackslashPathSet();
int dotPos = m_sBackslashPath.ReverseFind('.');
int slashPos = m_sBackslashPath.ReverseFind('\\');
if (dotPos > slashPos)
return m_sBackslashPath.Mid(dotPos);
return CString();
}
void CTGitPath::AppendPathString(const CString& sAppend)
{
EnsureBackslashPathSet();
CString cleanAppend(sAppend);
cleanAppend.Replace('/', '\\');
cleanAppend.TrimLeft('\\');
m_sBackslashPath.TrimRight('\\');
CString strCopy = m_sBackslashPath + _T("\\") + cleanAppend;
SetFromWin(strCopy);
}
bool CTSVNPath::IsWCRoot() const
{
if (m_bIsWCRootKnown)
return m_bIsWCRoot;
EnsureBackslashPathSet();
m_bIsWCRoot = g_SVNAdminDir.IsWCRoot(m_sBackslashPath);
m_bIsWCRootKnown = true;
return m_bIsWCRoot;
}
bool CTSVNPath::IsAdminDir() const
{
if (m_bIsAdminDirKnown)
return m_bIsAdminDir;
EnsureBackslashPathSet();
m_bIsAdminDir = g_SVNAdminDir.IsAdminDirPath(m_sBackslashPath);
m_bIsAdminDirKnown = true;
return m_bIsAdminDir;
}
bool CTGitPath::HasAdminDir() const
{
if (m_bHasAdminDirKnown)
return m_bHasAdminDir;
EnsureBackslashPathSet();
m_bHasAdminDir = GitAdminDir::HasAdminDir(m_sBackslashPath, IsDirectory(), &m_sProjectRoot);
m_bHasAdminDirKnown = true;
return m_bHasAdminDir;
}
void CTSVNPath::UpdateAttributes() const
{
EnsureBackslashPathSet();
WIN32_FILE_ATTRIBUTE_DATA attribs;
if (m_sBackslashPath.GetLength() >= 248)
m_sLongBackslashPath = L"\\\\?\\" + m_sBackslashPath;
if(GetFileAttributesEx(m_sBackslashPath.GetLength() >= 248 ? m_sLongBackslashPath : m_sBackslashPath, GetFileExInfoStandard, &attribs))
{
m_bIsDirectory = !!(attribs.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY);
// don't cast directly to an __int64:
// http://msdn.microsoft.com/en-us/library/windows/desktop/ms724284%28v=vs.85%29.aspx
// "Do not cast a pointer to a FILETIME structure to either a ULARGE_INTEGER* or __int64* value
// because it can cause alignment faults on 64-bit Windows."
m_lastWriteTime = static_cast<__int64>(attribs.ftLastWriteTime.dwHighDateTime) << 32 | attribs.ftLastWriteTime.dwLowDateTime;
if (m_bIsDirectory)
{
m_fileSize = 0;
}
else
{
m_fileSize = ((INT64)( (DWORD)(attribs.nFileSizeLow) ) | ( (INT64)( (DWORD)(attribs.nFileSizeHigh) )<<32 ));
}
m_bIsReadOnly = !!(attribs.dwFileAttributes & FILE_ATTRIBUTE_READONLY);
m_bExists = true;
m_bIsAttributesKnown = true;
m_attributes = attribs.dwFileAttributes;
}
else
{
DWORD err = GetLastError();
m_lastWriteTime = 0;
m_fileSize = 0;
if ((err == ERROR_FILE_NOT_FOUND)||(err == ERROR_PATH_NOT_FOUND)||(err == ERROR_INVALID_NAME))
{
m_bIsDirectory = false;
m_bExists = false;
}
else if (err == ERROR_NOT_READY)
{
// this is a device root (e.g. a DVD drive with no media in it)
m_bIsDirectory = true;
m_bExists = true;
}
else
{
m_bIsDirectory = false;
m_bExists = true;
return;
}
}
m_bDirectoryKnown = true;
m_bLastWriteTimeKnown = true;
m_bExistsKnown = true;
}
CString CTGitPath::GetFileExtension() const
{
if(!IsDirectory())
{
EnsureBackslashPathSet();
int dotPos = m_sBackslashPath.ReverseFind('.');
int slashPos = m_sBackslashPath.ReverseFind('\\');
if (dotPos > slashPos)
return m_sBackslashPath.Mid(dotPos);
}
return CString();
}
bool CTGitPath::IsAncestorOf(const CTGitPath& possibleDescendant) const
{
possibleDescendant.EnsureBackslashPathSet();
EnsureBackslashPathSet();
bool bPathStringsEqual = ArePathStringsEqual(m_sBackslashPath, possibleDescendant.m_sBackslashPath.Left(m_sBackslashPath.GetLength()));
if (m_sBackslashPath.GetLength() >= possibleDescendant.GetWinPathString().GetLength())
{
return bPathStringsEqual;
}
return (bPathStringsEqual &&
((possibleDescendant.m_sBackslashPath[m_sBackslashPath.GetLength()] == '\\')||
(m_sBackslashPath.GetLength()==3 && m_sBackslashPath[1]==':')));
}
bool CTGitPath::HasAdminDir(CString *ProjectTopDir) const
{
if (m_bHasAdminDirKnown)
{
if (ProjectTopDir)
*ProjectTopDir = m_sProjectRoot;
return m_bHasAdminDir;
}
EnsureBackslashPathSet();
m_bHasAdminDir = GitAdminDir::HasAdminDir(m_sBackslashPath, IsDirectory(), &m_sProjectRoot);
m_bHasAdminDirKnown = true;
if (ProjectTopDir)
*ProjectTopDir = m_sProjectRoot;
return m_bHasAdminDir;
}
bool CTGitPath::IsValidOnWindows() const
{
if (m_bIsValidOnWindowsKnown)
return m_bIsValidOnWindows;
m_bIsValidOnWindows = false;
EnsureBackslashPathSet();
CString sMatch = m_sBackslashPath + _T("\r\n");
std::wstring sPattern;
// the 'file://' URL is just a normal windows path:
if (sMatch.Left(7).CompareNoCase(_T("file:\\\\"))==0)
{
sMatch = sMatch.Mid(7);
sMatch.TrimLeft(_T("\\"));
sPattern = _T("^(\\\\\\\\\\?\\\\)?(([a-zA-Z]:|\\\\)\\\\)?(((\\.)|(\\.\\.)|([^\\\\/:\\*\\?\"\\|<> ](([^\\\\/:\\*\\?\"\\|<>\\. ])|([^\\\\/:\\*\\?\"\\|<>]*[^\\\\/:\\*\\?\"\\|<>\\. ]))?))\\\\)*[^\\\\/:\\*\\?\"\\|<> ](([^\\\\/:\\*\\?\"\\|<>\\. ])|([^\\\\/:\\*\\?\"\\|<>]*[^\\\\/:\\*\\?\"\\|<>\\. ]))?$");
}
else
{
sPattern = _T("^(\\\\\\\\\\?\\\\)?(([a-zA-Z]:|\\\\)\\\\)?(((\\.)|(\\.\\.)|([^\\\\/:\\*\\?\"\\|<> ](([^\\\\/:\\*\\?\"\\|<>\\. ])|([^\\\\/:\\*\\?\"\\|<>]*[^\\\\/:\\*\\?\"\\|<>\\. ]))?))\\\\)*[^\\\\/:\\*\\?\"\\|<> ](([^\\\\/:\\*\\?\"\\|<>\\. ])|([^\\\\/:\\*\\?\"\\|<>]*[^\\\\/:\\*\\?\"\\|<>\\. ]))?$");
}
try
{
std::tr1::wregex rx(sPattern, std::tr1::regex_constants::icase | std::tr1::regex_constants::ECMAScript);
std::tr1::wsmatch match;
std::wstring rmatch = std::wstring((LPCTSTR)sMatch);
if (std::tr1::regex_match(rmatch, match, rx))
{
if (std::wstring(match[0]).compare(sMatch)==0)
m_bIsValidOnWindows = true;
}
if (m_bIsValidOnWindows)
{
// now check for illegal filenames
std::tr1::wregex rx2(_T("\\\\(lpt\\d|com\\d|aux|nul|prn|con)(\\\\|$)"), std::tr1::regex_constants::icase | std::tr1::regex_constants::ECMAScript);
rmatch = m_sBackslashPath;
if (std::tr1::regex_search(rmatch, rx2, std::tr1::regex_constants::match_default))
m_bIsValidOnWindows = false;
}
}
catch (std::exception) {}
m_bIsValidOnWindowsKnown = true;
return m_bIsValidOnWindows;
}
CTGitPath CTGitPath::GetContainingDirectory() const
{
EnsureBackslashPathSet();
CString sDirName = m_sBackslashPath.Left(m_sBackslashPath.ReverseFind('\\'));
if(sDirName.GetLength() == 2 && sDirName[1] == ':')
{
// This is a root directory, which needs a trailing slash
sDirName += '\\';
if(sDirName == m_sBackslashPath)
{
// We were clearly provided with a root path to start with - we should return nothing now
sDirName.Empty();
}
}
if(sDirName.GetLength() == 1 && sDirName[0] == '\\')
{
// We have an UNC path and we already are the root
sDirName.Empty();
}
CTGitPath retVal;
retVal.SetFromWin(sDirName);
return retVal;
}
bool CTGitPath::Delete(bool bTrash) const
{
EnsureBackslashPathSet();
::SetFileAttributes(m_sBackslashPath, FILE_ATTRIBUTE_NORMAL);
bool bRet = false;
if (Exists())
{
if ((bTrash)||(IsDirectory()))
{
std::unique_ptr<TCHAR[]> buf(new TCHAR[m_sBackslashPath.GetLength() + 2]);
_tcscpy_s(buf.get(), m_sBackslashPath.GetLength() + 2, m_sBackslashPath);
buf[m_sBackslashPath.GetLength()] = 0;
buf[m_sBackslashPath.GetLength()+1] = 0;
bRet = CTGitPathList::DeleteViaShell(buf.get(), bTrash);
}
else
{
bRet = !!::DeleteFile(m_sBackslashPath);
}
}
m_bExists = false;
m_bExistsKnown = true;
return bRet;
}
CString CTGitPath::GetFileOrDirectoryName() const
{
EnsureBackslashPathSet();
return m_sBackslashPath.Mid(m_sBackslashPath.ReverseFind('\\')+1);
}
