/**
* Change the maximum size of the cache. If the new size is larger
* than the old size, then the oldest entries in the cache are
* removed.
*
* A size of 0 means unlimited.
*/
void setMaxSize(unsigned int maxSize) {
boost::unique_lock<boost::mutex> l(lock);
if (maxSize != 0) {
int toRemove = cache.size() - maxSize;
for (int i = 0; i < toRemove; i++) {
string filename(entries.back()->filename);
entries.pop_back();
cache.erase(filename);
}
}
this->maxSize = maxSize;
}
///////////////////////////////////////////////////////////////////////////////
// Read
//
size_t DirectoryIterator::Read(const char16_t* pDirectory, EntryList& entryList,
const char16_t* pFilterPattern, int nDirectoryEntryFlags,
size_t maxResultCount)
{
EntryFindData entryFindData, *pEntryFindData;
size_t resultCount = 0;
#if EASTL_NAME_ENABLED // If the EntryList doesn't have a unique name, we give it one here.
if(entryList.get_allocator().get_name() && !strcmp(EASTL_LIST_DEFAULT_NAME, entryList.get_allocator().get_name()))
entryList.get_allocator().set_name(ENTRYLIST_NAME);
#endif
// Iterate entries.
for(pEntryFindData = EntryFindFirst(pDirectory, pFilterPattern, &entryFindData); pEntryFindData && (resultCount < maxResultCount); )
{
if(!StrEq16(pEntryFindData->mName, EA_DIRECTORY_CURRENT_16) && // If it is neither "./" nor "../"
!StrEq16(pEntryFindData->mName, EA_DIRECTORY_PARENT_16))
{
if(pEntryFindData->mbIsDirectory)
{
if(nDirectoryEntryFlags & kDirectoryEntryDirectory)
{
resultCount++;
entryList.push_back();
entryList.back().mType = kDirectoryEntryDirectory;
entryList.back().msName = pEntryFindData->mName;
}
}
else
{
if(nDirectoryEntryFlags & kDirectoryEntryFile)
{
resultCount++;
entryList.push_back();
entryList.back().mType = kDirectoryEntryFile;
entryList.back().msName = pEntryFindData->mName;
}
}
}
if(!EntryFindNext(pEntryFindData))
{
EntryFindFinish(pEntryFindData);
break;
}
}
if(pEntryFindData)
{
if((nDirectoryEntryFlags & kDirectoryEntryCurrent) && (resultCount < maxResultCount))
{
resultCount++;
entryList.push_front();
entryList.front().mType = kDirectoryEntryDirectory;
entryList.front().msName = EA_DIRECTORY_CURRENT_16;
}
if((nDirectoryEntryFlags & kDirectoryEntryParent) && (resultCount < maxResultCount))
{
// To do: We don't want to do this if the directory is a root directory.
resultCount++;
entryList.push_front();
entryList.front().mType = kDirectoryEntryDirectory;
entryList.front().msName = EA_DIRECTORY_PARENT_16;
}
}
return resultCount;
}
///////////////////////////////////////////////////////////////////////////////
// ReadRecursive
//
size_t DirectoryIterator::ReadRecursive(const char16_t* pBaseDirectory, EntryList& entryList,
const char16_t* pFilterPattern, int nEntryTypeFlags,
bool bIncludeBaseDirectoryInSearch, bool bFullPaths,
size_t maxResultCount)
{
EA::IO::Path::PathString16 pathTemp;
//char16_t pathTemp[kMaxPathLength];
if(mnRecursionIndex++ == 0) // If being called for the first time...
{
#if EASTL_NAME_ENABLED // If the EntryList doesn't have a unique name, we give it one here.
if(entryList.get_allocator().get_name() && !strcmp(EASTL_LIST_DEFAULT_NAME, entryList.get_allocator().get_name()))
entryList.get_allocator().set_name(ENTRYLIST_NAME);
#endif
mnListSize = 0;
mpBaseDirectory = pBaseDirectory;
mBaseDirectoryLength = (eastl_size_t)EAIOStrlen16(pBaseDirectory);
if(!mBaseDirectoryLength || !IsFilePathSeparator(pBaseDirectory[mBaseDirectoryLength - 1]))
mBaseDirectoryLength++;
}
if((nEntryTypeFlags & kDirectoryEntryFile) &&
(bIncludeBaseDirectoryInSearch || (mnRecursionIndex > 1)) &&
(mnListSize < maxResultCount))
{
// Add all files in the current directory into the list, using the filter pattern.
const size_t additionCount = Read(pBaseDirectory, entryList, pFilterPattern, kDirectoryEntryFile, maxResultCount - mnListSize);
EntryList::iterator it(entryList.end());
eastl::advance(it, -(int32_t)(uint32_t)additionCount);
for(; it != entryList.end(); ++it)
{
Entry& entry = *it;
mnListSize++;
const eastl_size_t savedLength = entry.msName.length();
entry.msName.insert(0, pBaseDirectory);
const eastl_size_t directoryEnd = entry.msName.length() - savedLength;
if(directoryEnd && !IsFilePathSeparator(entry.msName[directoryEnd - 1]))
entry.msName.insert(directoryEnd, 1, kFilePathSeparator16);
if(!bFullPaths)
entry.msName.erase(0, mBaseDirectoryLength);
}
}
if(mnListSize < maxResultCount)
{
// To do: Find a way to avoid this temporary list.
// Since the list is only a list of directories under the
// current directory, it shouldn't need all that many entries.
EntryList entryListTemp(entryList.get_allocator());
// Add all directories in the current directory into the list, ignoring the filter pattern.
Read(pBaseDirectory, entryListTemp, NULL, kDirectoryEntryDirectory, kMaxEntryCountDefault);
for(EntryList::iterator it = entryListTemp.begin(); (it != entryListTemp.end()) && (mnListSize < maxResultCount); ++it)
{
const Entry& entry = *it;
pathTemp.assign( pBaseDirectory );
EA::IO::Path::Append( pathTemp, entry.msName.c_str() ); // This previously was Join but Join was calling Normalize, which was modifying the pBaseDirectory part of the path string, and we don't want that messed with. Actually we don't need any normalization.
//ConcatenatePathComponents(pathTemp, pBaseDirectory, entry.msName.c_str());
// Possibly add this directory to the entry list.
if(nEntryTypeFlags & kDirectoryEntryDirectory)
{
if(!pFilterPattern || FnMatch(pFilterPattern, entry.msName.c_str(), kFNMCaseFold))
{
mnListSize++;
entryList.push_back();
Entry& listEntry = entryList.back();
listEntry.mType = kDirectoryEntryDirectory;
listEntry.msName = pathTemp.c_str();
if(!bFullPaths)
listEntry.msName.erase(0, mBaseDirectoryLength);
}
}
// Now recursively read the subdirectory.
ReadRecursive(pathTemp.c_str(), entryList, pFilterPattern, nEntryTypeFlags, true, bFullPaths, maxResultCount);
}
}
mnRecursionIndex--;
return mnListSize;
}
