CStatusCacheEntry CSVNStatusCache::GetStatusForPath(const CTSVNPath& path, DWORD flags, bool bFetch /* = true */)
{
bool bRecursive = !!(flags & TSVNCACHE_FLAGS_RECUSIVE_STATUS);
// Check a very short-lived 'mini-cache' of the last thing we were asked for.
long now = (long)GetTickCount();
if(now-m_mostRecentExpiresAt < 0)
{
if(path.IsEquivalentToWithoutCase(m_mostRecentAskedPath))
{
return m_mostRecentStatus;
}
}
{
AutoLocker lock(m_critSec);
m_mostRecentAskedPath = path;
m_mostRecentExpiresAt = now+1000;
}
if (IsPathGood(path) && m_shellCache.IsPathAllowed(path.GetWinPath()))
{
// Stop the crawler starting on a new folder while we're doing this much more important task...
// Please note, that this may be a second "lock" used concurrently to the one in RemoveCacheForPath().
CCrawlInhibitor crawlInhibit(&m_folderCrawler);
CTSVNPath dirpath = path.GetContainingDirectory();
if (dirpath.IsEmpty())
dirpath = path.GetDirectory();
CCachedDirectory * cachedDir = GetDirectoryCacheEntry(dirpath);
if (cachedDir != NULL)
{
CStatusCacheEntry entry = cachedDir->GetStatusForMember(path, bRecursive, bFetch);
{
AutoLocker lock(m_critSec);
m_mostRecentStatus = entry;
return m_mostRecentStatus;
}
}
cachedDir = GetDirectoryCacheEntry(path.GetDirectory());
if (cachedDir != NULL)
{
CStatusCacheEntry entry = cachedDir->GetStatusForMember(path, bRecursive, bFetch);
{
AutoLocker lock(m_critSec);
m_mostRecentStatus = entry;
return m_mostRecentStatus;
}
}
}
AutoLocker lock(m_critSec);
m_mostRecentStatus = CStatusCacheEntry();
if (m_shellCache.ShowExcludedAsNormal() && path.IsDirectory() && m_shellCache.HasSVNAdminDir(path.GetWinPath(), true))
{
m_mostRecentStatus.ForceStatus(svn_wc_status_normal);
}
return m_mostRecentStatus;
}
/* Fetch is false, means fetch status from cache */
CStatusCacheEntry CGitStatusCache::GetStatusForPath(const CTGitPath& path, DWORD flags, bool bFetch /* = true */)
{
bool bRecursive = !!(flags & TGITCACHE_FLAGS_RECUSIVE_STATUS);
// Check a very short-lived 'mini-cache' of the last thing we were asked for.
long now = (long)GetTickCount();
if(now-m_mostRecentExpiresAt < 0)
{
if(path.IsEquivalentToWithoutCase(m_mostRecentPath))
{
return m_mostRecentStatus;
}
}
{
AutoLocker lock(m_critSec);
m_mostRecentPath = path;
m_mostRecentExpiresAt = now + 1000;
}
if (IsPathGood(path))
{
// Stop the crawler starting on a new folder while we're doing this much more important task...
// Please note, that this may be a second "lock" used concurrently to the one in RemoveCacheForPath().
CCrawlInhibitor crawlInhibit(&m_folderCrawler);
CTGitPath dirpath = path.GetContainingDirectory();
if ((dirpath.IsEmpty()) || (!m_shellCache.IsPathAllowed(dirpath.GetWinPath())))
dirpath = path.GetDirectory();
CCachedDirectory * cachedDir = GetDirectoryCacheEntry(dirpath);
if (cachedDir != NULL)
{
//ATLTRACE(_T("GetStatusForMember %d\n"), bFetch);
CStatusCacheEntry entry = cachedDir->GetStatusForMember(path, bRecursive, bFetch);
{
AutoLocker lock(m_critSec);
m_mostRecentStatus = entry;
return m_mostRecentStatus;
}
}
}
else
{
// path is blocked for some reason: return the cached status if we have one
// we do here only a cache search, absolutely no disk access is allowed!
CCachedDirectory::ItDir itMap = m_directoryCache.find(path.GetDirectory());
if ((itMap != m_directoryCache.end())&&(itMap->second))
{
if (path.IsDirectory())
{
CStatusCacheEntry entry = itMap->second->GetOwnStatus(false);
AutoLocker lock(m_critSec);
m_mostRecentStatus = entry;
return m_mostRecentStatus;
}
else
{
// We've found this directory in the cache
CCachedDirectory * cachedDir = itMap->second;
CStatusCacheEntry entry = cachedDir->GetCacheStatusForMember(path);
{
AutoLocker lock(m_critSec);
m_mostRecentStatus = entry;
return m_mostRecentStatus;
}
}
}
}
AutoLocker lock(m_critSec);
ATLTRACE(_T("ignored no good path %s\n"), path.GetWinPath());
m_mostRecentStatus = CStatusCacheEntry();
if (m_shellCache.ShowExcludedAsNormal() && path.IsDirectory() && m_shellCache.HasGITAdminDir(path.GetWinPath(), true))
{
ATLTRACE(_T("force status %s\n"), path.GetWinPath());
m_mostRecentStatus.ForceStatus(git_wc_status_normal);
}
return m_mostRecentStatus;
}
CStatusCacheEntry CCachedDirectory::GetStatusForMember(const CTSVNPath& path, bool bRecursive, bool bFetch /* = true */)
{
CStringA strCacheKey;
bool bThisDirectoryIsUnversioned = false;
bool bRequestForSelf = false;
if(path.IsEquivalentToWithoutCase(m_directoryPath))
{
bRequestForSelf = true;
}
// In all most circumstances, we ask for the status of a member of this directory.
ATLASSERT(m_directoryPath.IsEquivalentToWithoutCase(path.GetContainingDirectory()) || bRequestForSelf);
long long dbFileTime = CSVNStatusCache::Instance().WCRoots()->GetDBFileTime(m_directoryPath);
bool wcDbFileTimeChanged = (m_wcDbFileTime != dbFileTime);
if ( !wcDbFileTimeChanged )
{
if(m_wcDbFileTime == 0)
{
// We are a folder which is not in a working copy
bThisDirectoryIsUnversioned = true;
m_ownStatus.SetStatus(NULL, false, false);
// If a user removes the .svn directory, we get here with m_entryCache
// not being empty, but still us being unversioned
if (!m_entryCache.empty())
{
m_entryCache.clear();
}
ATLASSERT(m_entryCache.empty());
// However, a member *DIRECTORY* might be the top of WC
// so we need to ask them to get their own status
if(!path.IsDirectory())
{
if ((PathFileExists(path.GetWinPath()))||(bRequestForSelf))
return CStatusCacheEntry();
// the entry doesn't exist anymore!
// but we can't remove it from the cache here:
// the GetStatusForMember() method is called only with a read
// lock and not a write lock!
// So mark it for crawling, and let the crawler remove it
// later
CSVNStatusCache::Instance().AddFolderForCrawling(path.GetContainingDirectory());
return CStatusCacheEntry();
}
else
{
// If we're in the special case of a directory being asked for its own status
// and this directory is unversioned, then we should just return that here
if(bRequestForSelf)
{
return CStatusCacheEntry();
}
}
}
if (CSVNStatusCache::Instance().GetDirectoryCacheEntryNoCreate(path) != NULL)
{
// We don't have directory status in our cache
// Ask the directory if it knows its own status
CCachedDirectory * dirEntry = CSVNStatusCache::Instance().GetDirectoryCacheEntry(path);
if ((dirEntry)&&(dirEntry->IsOwnStatusValid()))
{
// To keep recursive status up to date, we'll request that children are all crawled again
// We have to do this because the directory watcher isn't very reliable (especially under heavy load)
// and also has problems with SUBSTed drives.
// If nothing has changed in those directories, this crawling is fast and only
// accesses two files for each directory.
if (bRecursive)
{
AutoLocker lock(dirEntry->m_critSec);
ChildDirStatus::const_iterator it;
for(it = dirEntry->m_childDirectories.begin(); it != dirEntry->m_childDirectories.end(); ++it)
{
CTSVNPath newpath;
CString winPath = CUnicodeUtils::GetUnicode (it->first);
newpath.SetFromWin(winPath, true);
CSVNStatusCache::Instance().AddFolderForCrawling(newpath);
}
}
return dirEntry->GetOwnStatus(bRecursive);
}
}
else
{
{
// if we currently are fetching the status of the directory
// we want the status for, we just return an empty entry here
// and don't wait for that fetching to finish.
// That's because fetching the status can take a *really* long
// time (e.g. if a commit is also in progress on that same
// directory), and we don't want to make the explorer appear
// to hang.
if ((!bFetch)&&(m_FetchingStatus))
{
if (m_directoryPath.IsAncestorOf(path))
{
m_currentFullStatus = m_mostImportantFileStatus = svn_wc_status_none;
return GetCacheStatusForMember(path);
}
}
}
// Look up a file in our own cache
AutoLocker lock(m_critSec);
strCacheKey = GetCacheKey(path);
CacheEntryMap::iterator itMap = m_entryCache.find(strCacheKey);
if(itMap != m_entryCache.end())
{
// We've hit the cache - check for timeout
if(!itMap->second.HasExpired((long)GetTickCount()))
{
if(itMap->second.DoesFileTimeMatch(path.GetLastWriteTime()))
{
if ((itMap->second.GetEffectiveStatus()!=svn_wc_status_missing)||(!PathFileExists(path.GetWinPath())))
{
// Note: the filetime matches after a modified has been committed too.
// So in that case, we would return a wrong status (e.g. 'modified' instead
// of 'normal') here.
return itMap->second;
}
}
}
}
}
}
else
{
if ((!bFetch)&&(m_FetchingStatus))
{
if (m_directoryPath.IsAncestorOf(path))
{
// returning empty status (status fetch in progress)
// also set the status to 'none' to have the status change and
// the shell updater invoked in the crawler
m_currentFullStatus = m_mostImportantFileStatus = svn_wc_status_none;
CSVNStatusCache::Instance().AddFolderForCrawling(m_directoryPath.GetDirectory());
return GetCacheStatusForMember(path);
}
}
// if we're fetching the status for the explorer,
// we don't refresh the status but use the one
// we already have (to save time and make the explorer
// more responsive in stress conditions).
// We leave the refreshing to the crawler.
if ((!bFetch)&&(m_wcDbFileTime))
{
CSVNStatusCache::Instance().AddFolderForCrawling(m_directoryPath.GetDirectory());
return GetCacheStatusForMember(path);
}
AutoLocker lock(m_critSec);
m_entryCache.clear();
strCacheKey = GetCacheKey(path);
}
// We've not got this item in the cache - let's add it
// We never bother asking SVN for the status of just one file, always for its containing directory
if (g_SVNAdminDir.IsAdminDirPath(path.GetWinPathString()))
{
// We're being asked for the status of an .SVN directory
// It's not worth asking for this
return CStatusCacheEntry();
}
{
if ((!bFetch)&&(m_FetchingStatus))
{
if (m_directoryPath.IsAncestorOf(path))
{
m_currentFullStatus = m_mostImportantFileStatus = svn_wc_status_none;
return GetCacheStatusForMember(path);
}
}
}
{
AutoLocker lock(m_critSec);
m_mostImportantFileStatus = svn_wc_status_none;
m_childDirectories.clear();
m_entryCache.clear();
m_ownStatus.SetStatus(NULL, false, false);
}
if(!bThisDirectoryIsUnversioned)
{
if (!SvnUpdateMembersStatus())
{
m_wcDbFileTime = 0;
return CStatusCacheEntry();
}
}
// Now that we've refreshed our SVN status, we can see if it's
// changed the 'most important' status value for this directory.
// If it has, then we should tell our parent
UpdateCurrentStatus();
m_wcDbFileTime = dbFileTime;
if (path.IsDirectory())
{
CCachedDirectory * dirEntry = CSVNStatusCache::Instance().GetDirectoryCacheEntry(path);
if ((dirEntry)&&(dirEntry->IsOwnStatusValid()))
{
//CSVNStatusCache::Instance().AddFolderForCrawling(path);
return dirEntry->GetOwnStatus(bRecursive);
}
// If the status *still* isn't valid here, it means that
// the current directory is unversioned, and we shall need to ask its children for info about themselves
if ((dirEntry)&&(dirEntry != this))
return dirEntry->GetStatusForMember(path,bRecursive);
// add the path for crawling: if it's really unversioned, the crawler will
// only check for the admin dir and do nothing more. But if it is
// versioned (could happen in a nested layout) the crawler will update its
// status correctly
CSVNStatusCache::Instance().AddFolderForCrawling(path);
return CStatusCacheEntry();
}
else
{
CacheEntryMap::iterator itMap = m_entryCache.find(strCacheKey);
if(itMap != m_entryCache.end())
{
return itMap->second;
}
}
AddEntry(path, NULL, false, false);
return CStatusCacheEntry();
}
void CFolderCrawler::WorkerThread()
{
HANDLE hWaitHandles[2];
hWaitHandles[0] = m_hTerminationEvent;
hWaitHandles[1] = m_hWakeEvent;
CTGitPath workingPath;
ULONGLONG currentTicks = 0;
for(;;)
{
bool bRecursive = !!(DWORD)CRegStdDWORD(L"Software\\TortoiseGit\\RecursiveOverlay", TRUE);
SetThreadPriority(GetCurrentThread(), THREAD_MODE_BACKGROUND_END);
DWORD waitResult = WaitForMultipleObjects(_countof(hWaitHandles), hWaitHandles, FALSE, INFINITE);
// exit event/working loop if the first event (m_hTerminationEvent)
// has been signaled or if one of the events has been abandoned
// (i.e. ~CFolderCrawler() is being executed)
if(m_bRun == false || waitResult == WAIT_OBJECT_0 || waitResult == WAIT_ABANDONED_0 || waitResult == WAIT_ABANDONED_0+1)
{
// Termination event
break;
}
SetThreadPriority(GetCurrentThread(), THREAD_MODE_BACKGROUND_BEGIN);
// If we get here, we've been woken up by something being added to the queue.
// However, it's important that we don't do our crawling while
// the shell is still asking for items
bool bFirstRunAfterWakeup = true;
for(;;)
{
if (!m_bRun)
break;
// Any locks today?
if (CGitStatusCache::Instance().m_bClearMemory)
{
CAutoWriteLock writeLock(CGitStatusCache::Instance().GetGuard());
CGitStatusCache::Instance().ClearCache();
CGitStatusCache::Instance().m_bClearMemory = false;
}
if(m_lCrawlInhibitSet > 0)
{
// We're in crawl hold-off
CTraceToOutputDebugString::Instance()(_T(__FUNCTION__) L": Crawl hold-off\n");
Sleep(50);
continue;
}
if (bFirstRunAfterWakeup)
{
Sleep(20);
CTraceToOutputDebugString::Instance()(_T(__FUNCTION__) L": Crawl bFirstRunAfterWakeup\n");
bFirstRunAfterWakeup = false;
continue;
}
if ((m_blockReleasesAt < GetTickCount64()) && (!m_blockedPath.IsEmpty()))
{
CTraceToOutputDebugString::Instance()(_T(__FUNCTION__) L": Crawl stop blocking path %s\n", m_blockedPath.GetWinPath());
m_blockedPath.Reset();
}
CGitStatusCache::Instance().RemoveTimedoutBlocks();
while (!m_pathsToRelease.empty())
{
AutoLocker lock(m_critSec);
CTGitPath path = m_pathsToRelease.Pop();
GitStatus::ReleasePath(path.GetWinPathString());
}
if (m_foldersToUpdate.empty() && m_pathsToUpdate.empty())
{
// Nothing left to do
break;
}
currentTicks = GetTickCount64();
if (!m_pathsToUpdate.empty())
{
{
AutoLocker lock(m_critSec);
m_bPathsAddedSinceLastCrawl = false;
workingPath = m_pathsToUpdate.Pop();
if ((!m_blockedPath.IsEmpty()) && (m_blockedPath.IsAncestorOf(workingPath)))
{
// move the path to the end of the list
m_pathsToUpdate.Push(workingPath);
if (m_pathsToUpdate.size() < 3)
Sleep(50);
continue;
}
}
// don't crawl paths that are excluded
if (!CGitStatusCache::Instance().IsPathAllowed(workingPath))
continue;
// check if the changed path is inside an .git folder
CString projectroot;
if ((workingPath.HasAdminDir(&projectroot)&&workingPath.IsDirectory()) || workingPath.IsAdminDir())
{
// we don't crawl for paths changed in a tmp folder inside an .git folder.
// Because we also get notifications for those even if we just ask for the status!
// And changes there don't affect the file status at all, so it's safe
// to ignore notifications on those paths.
if (workingPath.IsAdminDir())
{
// TODO: add git specific filters here. is there really any change besides index file in .git
// that is relevant for overlays?
/*CString lowerpath = workingPath.GetWinPathString();
lowerpath.MakeLower();
if (lowerpath.Find(L"\\tmp\\") > 0)
continue;
if (CStringUtils::EndsWith(lowerpath, L"\\tmp"))
continue;
if (lowerpath.Find(L"\\log") > 0)
continue;*/
// Here's a little problem:
// the lock file is also created for fetching the status
// and not just when committing.
// If we could find out why the lock file was changed
// we could decide to crawl the folder again or not.
// But for now, we have to crawl the parent folder
// no matter what.
//if (lowerpath.Find(L"\\lock") > 0)
// continue;
// only go back to wc root if we are in .git-dir
do
{
workingPath = workingPath.GetContainingDirectory();
} while(workingPath.IsAdminDir());
}
else if (!workingPath.Exists())
{
CAutoWriteLock writeLock(CGitStatusCache::Instance().GetGuard());
CGitStatusCache::Instance().RemoveCacheForPath(workingPath);
continue;
}
if (!CGitStatusCache::Instance().IsPathGood(workingPath))
{
AutoLocker lock(m_critSec);
// move the path, the root of the repository, to the end of the list
if (projectroot.IsEmpty())
m_pathsToUpdate.Push(workingPath);
else
m_pathsToUpdate.Push(CTGitPath(projectroot));
if (m_pathsToUpdate.size() < 3)
Sleep(50);
continue;
}
CTraceToOutputDebugString::Instance()(_T(__FUNCTION__) L": Invalidating and refreshing folder: %s\n", workingPath.GetWinPath());
{
AutoLocker print(critSec);
_sntprintf_s(szCurrentCrawledPath[nCurrentCrawledpathIndex], MAX_CRAWLEDPATHSLEN, _TRUNCATE, L"Invalidating and refreshing folder: %s", workingPath.GetWinPath());
++nCurrentCrawledpathIndex;
if (nCurrentCrawledpathIndex >= MAX_CRAWLEDPATHS)
nCurrentCrawledpathIndex = 0;
}
InvalidateRect(hWndHidden, nullptr, FALSE);
{
CAutoReadLock readLock(CGitStatusCache::Instance().GetGuard());
// Invalidate the cache of this folder, to make sure its status is fetched again.
CCachedDirectory * pCachedDir = CGitStatusCache::Instance().GetDirectoryCacheEntry(workingPath);
if (pCachedDir)
{
git_wc_status_kind status = pCachedDir->GetCurrentFullStatus();
pCachedDir->Invalidate();
if (workingPath.Exists())
{
pCachedDir->RefreshStatus(bRecursive);
// if the previous status wasn't normal and now it is, then
// send a notification too.
// We do this here because GetCurrentFullStatus() doesn't send
// notifications for 'normal' status - if it would, we'd get tons
// of notifications when crawling a working copy not yet in the cache.
if ((status != git_wc_status_normal) && (pCachedDir->GetCurrentFullStatus() != status))
{
CGitStatusCache::Instance().UpdateShell(workingPath);
CTraceToOutputDebugString::Instance()(_T(__FUNCTION__) L": shell update in crawler for %s\n", workingPath.GetWinPath());
}
}
else
{
CAutoWriteLock writeLock(CGitStatusCache::Instance().GetGuard());
CGitStatusCache::Instance().RemoveCacheForPath(workingPath);
}
}
}
//In case that svn_client_stat() modified a file and we got
//a notification about that in the directory watcher,
//remove that here again - this is to prevent an endless loop
AutoLocker lock(m_critSec);
m_pathsToUpdate.erase(workingPath);
}
else if (workingPath.HasAdminDir())
{
if (!workingPath.Exists())
{
CAutoWriteLock writeLock(CGitStatusCache::Instance().GetGuard());
CGitStatusCache::Instance().RemoveCacheForPath(workingPath);
if (!workingPath.GetContainingDirectory().Exists())
continue;
else
workingPath = workingPath.GetContainingDirectory();
}
CTraceToOutputDebugString::Instance()(_T(__FUNCTION__) L": Updating path: %s\n", workingPath.GetWinPath());
{
AutoLocker print(critSec);
_sntprintf_s(szCurrentCrawledPath[nCurrentCrawledpathIndex], MAX_CRAWLEDPATHSLEN, _TRUNCATE, L"Updating path: %s", workingPath.GetWinPath());
++nCurrentCrawledpathIndex;
if (nCurrentCrawledpathIndex >= MAX_CRAWLEDPATHS)
nCurrentCrawledpathIndex = 0;
}
InvalidateRect(hWndHidden, nullptr, FALSE);
{
CAutoReadLock readLock(CGitStatusCache::Instance().GetGuard());
// Invalidate the cache of folders manually. The cache of files is invalidated
// automatically if the status is asked for it and the file times don't match
// anymore, so we don't need to manually invalidate those.
CCachedDirectory* cachedDir = CGitStatusCache::Instance().GetDirectoryCacheEntry(workingPath.GetDirectory());
if (cachedDir && workingPath.IsDirectory())
cachedDir->Invalidate();
if (cachedDir && cachedDir->GetStatusForMember(workingPath, bRecursive).GetEffectiveStatus() > git_wc_status_unversioned)
CGitStatusCache::Instance().UpdateShell(workingPath);
}
AutoLocker lock(m_critSec);
m_pathsToUpdate.erase(workingPath);
}
else
{
if (!workingPath.Exists())
{
CAutoWriteLock writeLock(CGitStatusCache::Instance().GetGuard());
CGitStatusCache::Instance().RemoveCacheForPath(workingPath);
}
}
}
if (!m_foldersToUpdate.empty())
{
{
AutoLocker lock(m_critSec);
m_bItemsAddedSinceLastCrawl = false;
// create a new CTGitPath object to make sure the cached flags are requested again.
// without this, a missing file/folder is still treated as missing even if it is available
// now when crawling.
workingPath = CTGitPath(m_foldersToUpdate.Pop().GetWinPath());
if ((!m_blockedPath.IsEmpty())&&(m_blockedPath.IsAncestorOf(workingPath)))
{
// move the path to the end of the list
m_foldersToUpdate.Push(workingPath);
if (m_foldersToUpdate.size() < 3)
Sleep(50);
continue;
}
}
if ((!m_blockedPath.IsEmpty())&&(m_blockedPath.IsAncestorOf(workingPath)))
continue;
if (!CGitStatusCache::Instance().IsPathAllowed(workingPath))
continue;
if (!CGitStatusCache::Instance().IsPathGood(workingPath))
continue;
CTraceToOutputDebugString::Instance()(_T(__FUNCTION__) L": Crawling folder: %s\n", workingPath.GetWinPath());
{
AutoLocker print(critSec);
_sntprintf_s(szCurrentCrawledPath[nCurrentCrawledpathIndex], MAX_CRAWLEDPATHSLEN, _TRUNCATE, L"Crawling folder: %s", workingPath.GetWinPath());
++nCurrentCrawledpathIndex;
if (nCurrentCrawledpathIndex >= MAX_CRAWLEDPATHS)
nCurrentCrawledpathIndex = 0;
}
InvalidateRect(hWndHidden, nullptr, FALSE);
{
CAutoReadLock readLock(CGitStatusCache::Instance().GetGuard());
// Now, we need to visit this folder, to make sure that we know its 'most important' status
CCachedDirectory * cachedDir = CGitStatusCache::Instance().GetDirectoryCacheEntry(workingPath.GetDirectory());
// check if the path is monitored by the watcher. If it isn't, then we have to invalidate the cache
// for that path and add it to the watcher.
if (!CGitStatusCache::Instance().IsPathWatched(workingPath))
{
if (workingPath.HasAdminDir())
{
CTraceToOutputDebugString::Instance()(_T(__FUNCTION__) L": Add watch path %s\n", workingPath.GetWinPath());
CGitStatusCache::Instance().AddPathToWatch(workingPath);
}
if (cachedDir)
cachedDir->Invalidate();
else
{
CAutoWriteLock writeLock(CGitStatusCache::Instance().GetGuard());
CGitStatusCache::Instance().RemoveCacheForPath(workingPath);
// now cacheDir is invalid because it got deleted in the RemoveCacheForPath() call above.
cachedDir = nullptr;
}
}
if (cachedDir)
cachedDir->RefreshStatus(bRecursive);
}
// While refreshing the status, we could get another crawl request for the same folder.
// This can happen if the crawled folder has a lower status than one of the child folders
// (recursively). To avoid double crawlings, remove such a crawl request here
AutoLocker lock(m_critSec);
if (m_bItemsAddedSinceLastCrawl)
{
m_foldersToUpdate.erase(workingPath);
}
}
}
}
_endthread();
}
