From 53ebf9f7ae01e626ff935e3f71171e45ebe647d5 Mon Sep 17 00:00:00 2001 From: danij Date: Sun, 7 Oct 2012 03:52:53 +0100 Subject: [PATCH] Refactor|AbstractFile: Return const references to lump infos and directory nodes --- .../engine/portable/include/abstractfile.h | 49 ++++++++++++++++--- .../engine/portable/include/genericfile.h | 17 ++----- doomsday/engine/portable/include/lumpfile.h | 19 ++----- .../engine/portable/include/pathdirectory.h | 4 +- doomsday/engine/portable/include/wadfile.h | 14 +++--- doomsday/engine/portable/include/zipfile.h | 14 +++--- doomsday/engine/portable/src/abstractfile.cpp | 4 +- doomsday/engine/portable/src/dfile.cpp | 8 +-- doomsday/engine/portable/src/fs_main.cpp | 23 ++++----- doomsday/engine/portable/src/genericfile.cpp | 20 +++----- doomsday/engine/portable/src/lumpfile.cpp | 41 ++++++++-------- doomsday/engine/portable/src/lumpindex.cpp | 13 +++-- .../engine/portable/src/pathdirectorynode.cpp | 8 +-- doomsday/engine/portable/src/wadfile.cpp | 46 ++++++++--------- doomsday/engine/portable/src/zipfile.cpp | 45 ++++++++--------- 15 files changed, 164 insertions(+), 161 deletions(-) diff --git a/doomsday/engine/portable/include/abstractfile.h b/doomsday/engine/portable/include/abstractfile.h index f3ba9b421c..3af48603f9 100644 --- a/doomsday/engine/portable/include/abstractfile.h +++ b/doomsday/engine/portable/include/abstractfile.h @@ -89,7 +89,7 @@ class AbstractFile /** * @return Immutable copy of the info descriptor for this resource. */ - LumpInfo const* info() const; + LumpInfo const& info() const; /// @return @c true= this file is contained within another. bool isContained() const; @@ -128,19 +128,43 @@ class AbstractFile * @todo Extract these into one or more interface classes/subcomponents. */ + /** + * @return @c true= @a lumpIdx is a valid logical index for a lump in this file. + * + * @attention This default implementation assumes there is only one lump in + * the file. Subclasses with multiple lumps should override this function + * accordingly. + */ + virtual bool isValidIndex(int lumpIdx) { return lumpIdx == 0; } + + /** + * @return Logical index of the last lump in this file's directory or @c -1 if empty. + * + * @attention This default implementation assumes there is only one lump in + * the file. Subclasses with multiple lumps should override this function + * accordingly. + */ + virtual int lastIndex() { return 0; } + /** * @return Number of "lumps" contained within this resource. + * + * @attention This default implementation assumes there is only one lump in + * the file. Subclasses with multiple lumps should override this function + * accordingly. */ virtual int lumpCount() { return 1; } /** - * Lookup a directory node for a lump contained by this file. + * Retrieve the directory node for a lump contained by this file. * * @param lumpIdx Logical index for the lump in this file's directory. * - * @return Found directory node else @c NULL if @a lumpIdx is not valid. + * @return Directory node for this lump. + * + * @throws de::Error If @a lumpIdx is not valid. */ - virtual PathDirectoryNode* lumpDirectoryNode(int lumpIdx) = 0; + virtual PathDirectoryNode const& lumpDirectoryNode(int lumpIdx) = 0; /** * Compose the absolute VFS path to a lump contained by this file. @@ -156,13 +180,19 @@ class AbstractFile virtual AutoStr* composeLumpPath(int lumpIdx, char delimiter = '/') = 0; /** - * Lookup a lump info descriptor for a lump contained by this file. + * Retrieve the LumpInfo descriptor for a lump contained by this file. * * @param lumpIdx Logical index for the lump in this file's directory. * - * @return Found lump info. + * @return Lump info descriptor for the lump. + * + * @throws de::Error If @a lumpIdx is not valid. + * + * @attention This default implementation assumes there is only one lump in + * the file and therefore its decriptor is that of the file itself. Subclasses + * with multiple lumps should override this function accordingly. */ - virtual LumpInfo const* lumpInfo(int /*lumpIdx*/) { return info(); } + virtual LumpInfo const& lumpInfo(int /*lumpIdx*/) { return info(); } /** * Lookup the uncompressed size of lump contained by this file. @@ -173,6 +203,11 @@ class AbstractFile * * @note This method is intended mainly for convenience. @see lumpInfo() for * a better method of looking up multiple @ref LumpInfo properties. + * + * @attention This default implementation assumes there is only one lump in + * the file and therefore its decriptor is that of the file itself. Subclasses + * with multiple lumps should override this function accordingly. + * */ virtual size_t lumpSize(int lumpIdx) = 0; diff --git a/doomsday/engine/portable/include/genericfile.h b/doomsday/engine/portable/include/genericfile.h index 3f06463580..9b7d812941 100644 --- a/doomsday/engine/portable/include/genericfile.h +++ b/doomsday/engine/portable/include/genericfile.h @@ -47,13 +47,15 @@ class GenericFile : public AbstractFile ~GenericFile(); /** - * Lookup a directory node for a lump contained by this file. + * Retrieve the directory node for a lump contained by this file. * * @param lumpIdx Logical index for the lump in this file's directory. * - * @return Found directory node else @c NULL if @a lumpIdx is not valid. + * @return Directory node for this lump. + * + * @throws de::Error If @a lumpIdx is not valid. */ - PathDirectoryNode* lumpDirectoryNode(int lumpIdx); + PathDirectoryNode const& lumpDirectoryNode(int lumpIdx); /** * Compose the absolute VFS path to a lump contained by this file. @@ -68,15 +70,6 @@ class GenericFile : public AbstractFile */ AutoStr* composeLumpPath(int lumpIdx, char delimiter = '/'); - /** - * Lookup the lump info descriptor for this lump. - * - * @param lumpIdx Ignored. Required argument. - * - * @return Found lump info. - */ - LumpInfo const* lumpInfo(int lumpIdx); - /** * Lookup the uncompressed size of lump contained by this file. * diff --git a/doomsday/engine/portable/include/lumpfile.h b/doomsday/engine/portable/include/lumpfile.h index bd9b88d8ce..3f0bc08a2d 100644 --- a/doomsday/engine/portable/include/lumpfile.h +++ b/doomsday/engine/portable/include/lumpfile.h @@ -53,13 +53,13 @@ class LumpFile : public AbstractFile ~LumpFile(); /** - * Lookup a directory node for a lump contained by this file. + * Retrieve the directory node for a lump contained by this file. * - * @param lumpIdx Logical index for the lump in this file's directory. + * @param lumpIdx Ignored. Required argument. * - * @return Found directory node else @c NULL if @a lumpIdx is not valid. + * @return Directory node for this lump. */ - PathDirectoryNode* lumpDirectoryNode(int lumpIdx); + PathDirectoryNode const& lumpDirectoryNode(int lumpIdx); /** * Compose the absolute VFS path to a lump contained by this file. @@ -74,15 +74,6 @@ class LumpFile : public AbstractFile */ AutoStr* composeLumpPath(int lumpIdx, char delimiter = '/'); - /** - * Lookup the lump info descriptor for this lump. - * - * @param lumpIdx Ignored. Required argument. - * - * @return Found lump info. - */ - LumpInfo const* lumpInfo(int lumpIdx); - /** * Lookup the uncompressed size of lump contained by this file. * @@ -167,4 +158,4 @@ struct lumpfile_s; // The lumpfile instance (opaque) } // extern "C" #endif -#endif /* LIBDENG_FILESYS_LUMPFILE_H */ \ No newline at end of file +#endif /* LIBDENG_FILESYS_LUMPFILE_H */ diff --git a/doomsday/engine/portable/include/pathdirectory.h b/doomsday/engine/portable/include/pathdirectory.h index 96dd4abbad..25ad527676 100644 --- a/doomsday/engine/portable/include/pathdirectory.h +++ b/doomsday/engine/portable/include/pathdirectory.h @@ -118,10 +118,10 @@ class PathDirectoryNode * another PathDirectoryNode (possibly from another PathDirectory instance). This * would allow for further optimizations in the file system (among others) -ds */ - int matchDirectory(int flags, PathMap* candidatePath); + int matchDirectory(int flags, PathMap* candidatePath) const; /// @return The path fragment which this node represents. - const ddstring_t* pathFragment() const; + ddstring_t const* pathFragment() const; /** * Composes and/or calculates the composed-length of the path for this node. diff --git a/doomsday/engine/portable/include/wadfile.h b/doomsday/engine/portable/include/wadfile.h index aa42a09886..937aa2964c 100644 --- a/doomsday/engine/portable/include/wadfile.h +++ b/doomsday/engine/portable/include/wadfile.h @@ -59,13 +59,15 @@ class WadFile : public AbstractFile bool empty(); /** - * Lookup a directory node for a lump contained by this file. + * Retrieve the directory node for a lump contained by this file. * * @param lumpIdx Logical index for the lump in this file's directory. * - * @return Found directory node else @c NULL if @a lumpIdx is not valid. + * @return Directory node for this lump. + * + * @throws de::Error If @a lumpIdx is not valid. */ - PathDirectoryNode* lumpDirectoryNode(int lumpIdx); + PathDirectoryNode& lumpDirectoryNode(int lumpIdx); /** * Compose the absolute VFS path to a lump contained by this file. @@ -81,15 +83,15 @@ class WadFile : public AbstractFile AutoStr* composeLumpPath(int lumpIdx, char delimiter = '/'); /** - * Lookup a lump info descriptor for a lump contained by this file. + * Retrieve the LumpInfo descriptor for a lump contained by this file. * * @param lumpIdx Logical index for the lump in this file's directory. * - * @return Found lump info. + * @return Lump info descriptor for the lump. * * @throws de::Error If @a lumpIdx is not valid. */ - LumpInfo const* lumpInfo(int lumpIdx); + LumpInfo const& lumpInfo(int lumpIdx); /** * Lookup the uncompressed size of lump contained by this file. diff --git a/doomsday/engine/portable/include/zipfile.h b/doomsday/engine/portable/include/zipfile.h index c50dd5ab21..ec473e12de 100644 --- a/doomsday/engine/portable/include/zipfile.h +++ b/doomsday/engine/portable/include/zipfile.h @@ -61,13 +61,15 @@ class ZipFile : public AbstractFile bool empty(); /** - * Lookup a directory node for a lump contained by this file. + * Retrieve the directory node for a lump contained by this file. * * @param lumpIdx Logical index for the lump in this file's directory. * - * @return Found directory node else @c NULL if @a lumpIdx is not valid. + * @return Directory node for this lump. + * + * @throws de::Error If @a lumpIdx is not valid. */ - PathDirectoryNode* lumpDirectoryNode(int lumpIdx); + PathDirectoryNode& lumpDirectoryNode(int lumpIdx); /** * Compose the absolute VFS path to a lump contained by this file. @@ -83,15 +85,15 @@ class ZipFile : public AbstractFile AutoStr* composeLumpPath(int lumpIdx, char delimiter = '/'); /** - * Lookup a lump info descriptor for a lump contained by this file. + * Retrieve the LumpInfo descriptor for a lump contained by this file. * * @param lumpIdx Logical index for the lump in this file's directory. * - * @return Found lump info. + * @return Lump info descriptor for the lump. * * @throws de::Error If @a lumpIdx is not valid. */ - LumpInfo const* lumpInfo(int lumpIdx); + LumpInfo const& lumpInfo(int lumpIdx); /** * Lookup the uncompressed size of lump contained by this file. diff --git a/doomsday/engine/portable/src/abstractfile.cpp b/doomsday/engine/portable/src/abstractfile.cpp index 7c8603f941..806bd1be22 100644 --- a/doomsday/engine/portable/src/abstractfile.cpp +++ b/doomsday/engine/portable/src/abstractfile.cpp @@ -61,9 +61,9 @@ filetype_t AbstractFile::type() const return type_; } -LumpInfo const* AbstractFile::info() const +LumpInfo const& AbstractFile::info() const { - return &info_; + return info_; } bool AbstractFile::isContained() const diff --git a/doomsday/engine/portable/src/dfile.cpp b/doomsday/engine/portable/src/dfile.cpp index bf46db332c..18ff890119 100644 --- a/doomsday/engine/portable/src/dfile.cpp +++ b/doomsday/engine/portable/src/dfile.cpp @@ -126,15 +126,15 @@ void DFileBuilder::shutdown(void) DFile* DFileBuilder::fromFileLump(AbstractFile& container, int lumpIdx, bool dontBuffer) { - LumpInfo const* info = container.lumpInfo(lumpIdx); - if(!info) return NULL; + if(!container.isValidIndex(lumpIdx)) return 0; + LumpInfo const& info = container.lumpInfo(lumpIdx); DFile* file = new DFile(); // Init and load in the lump data. file->d->flags.open = true; if(!dontBuffer) { - file->d->size = info->size; + file->d->size = info.size; file->d->pos = file->d->data = (uint8_t*) M_Malloc(file->d->size); if(!file->d->data) Con_Error("DFileBuilder::fromFileLump: Failed on allocation of %lu bytes for data buffer.", @@ -147,7 +147,7 @@ DFile* DFileBuilder::fromFileLump(AbstractFile& container, int lumpIdx, bool don F_PrettyPath(Str_Text(path))); ) #endif - container.readLump(lumpIdx, (uint8_t*)file->d->data, 0, info->size); + container.readLump(lumpIdx, (uint8_t*)file->d->data, 0, info.size); } return file; } diff --git a/doomsday/engine/portable/src/fs_main.cpp b/doomsday/engine/portable/src/fs_main.cpp index d080aa4e29..12d804124d 100644 --- a/doomsday/engine/portable/src/fs_main.cpp +++ b/doomsday/engine/portable/src/fs_main.cpp @@ -769,8 +769,8 @@ char const* FS::lumpName(lumpnum_t absoluteLumpNum) if(info) { AbstractFile* container = reinterpret_cast(info->container); - PathDirectoryNode* node = container->lumpDirectoryNode(info->lumpIdx); - return Str_Text(node->pathFragment()); + PathDirectoryNode const& node = container->lumpDirectoryNode(info->lumpIdx); + return Str_Text(node.pathFragment()); } return ""; } @@ -915,10 +915,7 @@ bool FS::dumpLump(lumpnum_t absoluteLumpNum, char const* path) { int lumpIdx; AbstractFile* file = lumpFile(absoluteLumpNum, &lumpIdx); - if(!file) return false; - - LumpInfo const* info = file->lumpInfo(lumpIdx); - if(!info) return false; + if(!file || !file->isValidIndex(lumpIdx)) return false; char const* lumpName = FS::lumpName(absoluteLumpNum); char const* fname; @@ -931,7 +928,7 @@ bool FS::dumpLump(lumpnum_t absoluteLumpNum, char const* path) fname = lumpName; } - bool dumpedOk = dump(file->cacheLump(lumpIdx), info->size, fname); + bool dumpedOk = dump(file->cacheLump(lumpIdx), file->lumpInfo(lumpIdx).size, fname); file->unlockLump(lumpIdx); if(!dumpedOk) return false; @@ -1261,8 +1258,7 @@ int FS::allResourcePaths(char const* rawSearchPattern, int flags, LumpInfo const* lumpInfo = *i; AbstractFile* container = reinterpret_cast(lumpInfo->container); DENG_ASSERT(container); - PathDirectoryNode* node = container->lumpDirectoryNode(lumpInfo->lumpIdx); - DENG_ASSERT(node); + PathDirectoryNode const& node = container->lumpDirectoryNode(lumpInfo->lumpIdx); AutoStr* filePath = 0; bool patternMatched; @@ -1273,7 +1269,7 @@ int FS::allResourcePaths(char const* rawSearchPattern, int flags, } else { - patternMatched = node->matchDirectory(PCF_MATCH_FULL, &patternMap); + patternMatched = node.matchDirectory(PCF_MATCH_FULL, &patternMap); if(patternMatched) { filePath = container->composeLumpPath(lumpInfo->lumpIdx); @@ -1477,7 +1473,7 @@ static DFile* openAsLumpFile(AbstractFile* container, int lumpIdx, // Prepare the temporary info descriptor. LumpInfo info; F_InitLumpInfo(&info); - F_CopyLumpInfo(&info, container->lumpInfo(lumpIdx)); + F_CopyLumpInfo(&info, &container->lumpInfo(lumpIdx)); // Try to open the referenced file as a specialised file type. DFile* file = tryOpenFile3(hndl, Str_Text(&absPath), &info); @@ -1803,7 +1799,7 @@ DFile* FS::openLump(lumpnum_t absoluteLumpNum) LumpFile* lump = new LumpFile(*DFileBuilder::fromFileLump(*container, lumpIdx, false), Str_Text(container->composeLumpPath(lumpIdx)), - *container->lumpInfo(lumpIdx)); + container->lumpInfo(lumpIdx)); if(!lump) return 0; DFile* openFileHndl = DFileBuilder::fromFile(*lump); @@ -2521,7 +2517,8 @@ LumpInfo const* F_LumpInfo(struct abstractfile_s* _file, int lumpIdx) { if(!_file) return 0; AbstractFile* file = reinterpret_cast(_file); - return file->lumpInfo(lumpIdx); + if(!file->isValidIndex(lumpIdx)) return 0; + return &file->lumpInfo(lumpIdx); } size_t F_ReadLump(struct abstractfile_s* _file, int lumpIdx, uint8_t* buffer) diff --git a/doomsday/engine/portable/src/genericfile.cpp b/doomsday/engine/portable/src/genericfile.cpp index 0a883c9fe4..db12b60ce8 100644 --- a/doomsday/engine/portable/src/genericfile.cpp +++ b/doomsday/engine/portable/src/genericfile.cpp @@ -44,10 +44,10 @@ GenericFile::GenericFile(DFile& file, char const* path, LumpInfo const& info) GenericFile::~GenericFile() {} -PathDirectoryNode* GenericFile::lumpDirectoryNode(int /*lumpIdx*/) +PathDirectoryNode const& GenericFile::lumpDirectoryNode(int /*lumpIdx*/) { /// @todo writeme - return 0; + throw de::Error("GenericFile::lumpDirectoryNode", "Not yet implemented"); } AutoStr* GenericFile::composeLumpPath(int /*lumpIdx*/, char /*delimiter*/) @@ -55,41 +55,35 @@ AutoStr* GenericFile::composeLumpPath(int /*lumpIdx*/, char /*delimiter*/) return AutoStr_NewStd(); } -LumpInfo const* GenericFile::lumpInfo(int /*lumpIdx*/) -{ - // Generic files are special cases for this *is* the lump. - return info(); -} - size_t GenericFile::lumpSize(int lumpIdx) { // Generic files are special cases for this *is* the lump. - return lumpInfo(lumpIdx)->size; + return lumpInfo(lumpIdx).size; } size_t GenericFile::readLump(int lumpIdx, uint8_t* buffer, bool tryCache) { /// @todo writeme - return 0; + throw de::Error("GenericFile::readLump", "Not yet implemented"); } size_t GenericFile::readLump(int lumpIdx, uint8_t* buffer, size_t startOffset, size_t length, bool tryCache) { /// @todo writeme - return 0; + throw de::Error("GenericFile::readLump", "Not yet implemented"); } uint8_t const* GenericFile::cacheLump(int /*lumpIdx*/) { /// @todo writeme - return 0; + throw de::Error("GenericFile::cacheLump", "Not yet implemented"); } GenericFile& GenericFile::unlockLump(int /*lumpIdx*/) { /// @todo writeme - return *this; + throw de::Error("GenericFile::unlockLump", "Not yet implemented"); } int GenericFile::publishLumpsToIndex(LumpIndex& index) diff --git a/doomsday/engine/portable/src/lumpfile.cpp b/doomsday/engine/portable/src/lumpfile.cpp index 044cfb99d6..67a41ffdd6 100644 --- a/doomsday/engine/portable/src/lumpfile.cpp +++ b/doomsday/engine/portable/src/lumpfile.cpp @@ -41,48 +41,47 @@ LumpFile::LumpFile(DFile& file, char const* path, LumpInfo const& info) LumpFile::~LumpFile() {} -PathDirectoryNode* LumpFile::lumpDirectoryNode(int lumpIdx) +PathDirectoryNode const& LumpFile::lumpDirectoryNode(int /*lumpIdx*/) { - return container().lumpDirectoryNode(lumpInfo(lumpIdx)->lumpIdx); -} - -AutoStr* LumpFile::composeLumpPath(int lumpIdx, char delimiter) -{ - return container().composeLumpPath(lumpInfo(lumpIdx)->lumpIdx, delimiter); + // Lump files are special cases for this *is* the lump. + return container().lumpDirectoryNode(info().lumpIdx); } -LumpInfo const* LumpFile::lumpInfo(int /*lumpIdx*/) +AutoStr* LumpFile::composeLumpPath(int /*lumpIdx*/, char delimiter) { // Lump files are special cases for this *is* the lump. - return info(); + return container().composeLumpPath(info().lumpIdx, delimiter); } -size_t LumpFile::lumpSize(int lumpIdx) +size_t LumpFile::lumpSize(int /*lumpIdx*/) { // Lump files are special cases for this *is* the lump. - return lumpInfo(lumpIdx)->size; + return info().size; } -size_t LumpFile::readLump(int lumpIdx, uint8_t* buffer, bool tryCache) +size_t LumpFile::readLump(int /*lumpIdx*/, uint8_t* buffer, bool tryCache) { - return container().readLump(lumpInfo(lumpIdx)->lumpIdx, buffer, tryCache); + // Lump files are special cases for this *is* the lump. + return container().readLump(info().lumpIdx, buffer, tryCache); } -size_t LumpFile::readLump(int lumpIdx, uint8_t* buffer, size_t startOffset, +size_t LumpFile::readLump(int /*lumpIdx*/, uint8_t* buffer, size_t startOffset, size_t length, bool tryCache) { - return container().readLump(lumpInfo(lumpIdx)->lumpIdx, buffer, - startOffset, length, tryCache); + // Lump files are special cases for this *is* the lump. + return container().readLump(info().lumpIdx, buffer, startOffset, length, tryCache); } -uint8_t const* LumpFile::cacheLump(int lumpIdx) +uint8_t const* LumpFile::cacheLump(int /*lumpIdx*/) { - return container().cacheLump(lumpInfo(lumpIdx)->lumpIdx); + // Lump files are special cases for this *is* the lump. + return container().cacheLump(info().lumpIdx); } -LumpFile& LumpFile::unlockLump(int lumpIdx) +LumpFile& LumpFile::unlockLump(int /*lumpIdx*/) { - container().unlockLump(lumpInfo(lumpIdx)->lumpIdx); + // Lump files are special cases for this *is* the lump. + container().unlockLump(info().lumpIdx); return *this; } @@ -90,6 +89,6 @@ int LumpFile::publishLumpsToIndex(LumpIndex& index) { LOG_AS("LumpFile"); // This *is* the lump, so insert ourself as a lump of our container in the index. - index.catalogLumps(container(), info()->lumpIdx, 1); + index.catalogLumps(container(), info().lumpIdx, 1); return 1; } diff --git a/doomsday/engine/portable/src/lumpindex.cpp b/doomsday/engine/portable/src/lumpindex.cpp index 2c867dcdd9..3e37a3e75c 100644 --- a/doomsday/engine/portable/src/lumpindex.cpp +++ b/doomsday/engine/portable/src/lumpindex.cpp @@ -93,8 +93,8 @@ struct LumpIndex::Instance { LumpInfo const* lumpInfo = lumpInfos[i]; AbstractFile* container = reinterpret_cast(lumpInfo->container); - PathDirectoryNode const* node = container->lumpDirectoryNode(lumpInfo->lumpIdx); - ushort j = node->hash() % (unsigned)numRecords; + PathDirectoryNode const& node = container->lumpDirectoryNode(lumpInfo->lumpIdx); + ushort j = node.hash() % (unsigned)numRecords; (*hashMap)[i].next = (*hashMap)[j].head; // Prepend to the chain. (*hashMap)[j].head = i; @@ -331,9 +331,8 @@ void LumpIndex::catalogLumps(de::AbstractFile& file, int lumpIdxBase, int numLum for(int i = 0; i < numLumps; ++i) { - LumpInfo const* lumpInfo = file.lumpInfo(lumpIdxBase + i); - DENG_ASSERT(lumpInfo); - d->lumpInfos.push_back(lumpInfo); + LumpInfo const* info = &file.lumpInfo(lumpIdxBase + i); + d->lumpInfos.push_back(info); } // We'll need to rebuild the name hash chains. @@ -386,7 +385,7 @@ lumpnum_t LumpIndex::indexForPath(char const* path) { LumpInfo const* lumpInfo = d->lumpInfos[idx]; AbstractFile* container = reinterpret_cast(lumpInfo->container); - PathDirectoryNode* node = container->lumpDirectoryNode(lumpInfo->lumpIdx); + PathDirectoryNode const& node = container->lumpDirectoryNode(lumpInfo->lumpIdx); // Time to build the pattern? if(!builtSearchPattern) @@ -395,7 +394,7 @@ lumpnum_t LumpIndex::indexForPath(char const* path) builtSearchPattern = true; } - if(node->matchDirectory(0, &searchPattern)) + if(node.matchDirectory(0, &searchPattern)) { // This is the lump we are looking for. break; diff --git a/doomsday/engine/portable/src/pathdirectorynode.cpp b/doomsday/engine/portable/src/pathdirectorynode.cpp index 865c0c4548..5810580a70 100644 --- a/doomsday/engine/portable/src/pathdirectorynode.cpp +++ b/doomsday/engine/portable/src/pathdirectorynode.cpp @@ -139,7 +139,7 @@ static int matchPathFragment(const char* string, const char* pattern) /// @note This routine is also used as an iteration callback, so only return /// a non-zero value when the node is a match for the search term. -int de::PathDirectoryNode::matchDirectory(int flags, PathMap* searchPattern) +int de::PathDirectoryNode::matchDirectory(int flags, PathMap* searchPattern) const { if(((flags & PCF_NO_LEAF) && PT_LEAF == type()) || ((flags & PCF_NO_BRANCH) && PT_BRANCH == type())) @@ -158,7 +158,7 @@ int de::PathDirectoryNode::matchDirectory(int flags, PathMap* searchPattern) PathDirectory& pd = directory(); uint fragmentCount = PathMap_Size(searchPattern); - de::PathDirectoryNode* node = this; + de::PathDirectoryNode const* node = this; for(uint i = 0; i < fragmentCount; ++i) { if(i == 0 && node->type() == PT_LEAF) @@ -166,7 +166,7 @@ int de::PathDirectoryNode::matchDirectory(int flags, PathMap* searchPattern) char buf[256]; qsnprintf(buf, 256, "%*s", sfragment->to - sfragment->from + 1, sfragment->from); - const ddstring_t* fragment = pd.pathFragment(node); + ddstring_t const* fragment = pd.pathFragment(node); DENG2_ASSERT(fragment); if(!matchPathFragment(Str_Text(fragment), buf)) @@ -195,7 +195,7 @@ int de::PathDirectoryNode::matchDirectory(int flags, PathMap* searchPattern) sfraglen = (sfragment->to - sfragment->from) + 1; // Compare the path fragment to that of the search term. - const ddstring_t* fragment = pd.pathFragment(node); + ddstring_t const* fragment = pd.pathFragment(node); if(Str_Length(fragment) < sfraglen || qstrnicmp(Str_Text(fragment), sfragment->from, Str_Length(fragment))) { diff --git a/doomsday/engine/portable/src/wadfile.cpp b/doomsday/engine/portable/src/wadfile.cpp index bdde756cee..e74672a4ea 100644 --- a/doomsday/engine/portable/src/wadfile.cpp +++ b/doomsday/engine/portable/src/wadfile.cpp @@ -316,13 +316,6 @@ bool WadFile::empty() return !lumpCount(); } -PathDirectoryNode* WadFile::lumpDirectoryNode(int lumpIdx) -{ - if(!isValidIndex(lumpIdx)) return NULL; - d->buildLumpNodeLut(); - return (*d->lumpNodeLut)[lumpIdx]; -} - static QString invalidIndexMessage(int invalidIdx, int lastValidIdx) { QString msg = QString("Invalid lump index %1 ").arg(invalidIdx); @@ -331,12 +324,19 @@ static QString invalidIndexMessage(int invalidIdx, int lastValidIdx) return msg; } -LumpInfo const* WadFile::lumpInfo(int lumpIdx) +PathDirectoryNode& WadFile::lumpDirectoryNode(int lumpIdx) +{ + if(!isValidIndex(lumpIdx)) throw Error("WadFile::lumpDirectoryNode", invalidIndexMessage(lumpIdx, lastIndex())); + d->buildLumpNodeLut(); + return *((*d->lumpNodeLut)[lumpIdx]); +} + +LumpInfo const& WadFile::lumpInfo(int lumpIdx) { LOG_AS("WadFile"); WadLumpRecord* lrec = d->lumpRecord(lumpIdx); if(!lrec) throw Error("WadFile::lumpInfo", invalidIndexMessage(lumpIdx, lastIndex())); - return &lrec->info; + return lrec->info; } size_t WadFile::lumpSize(int lumpIdx) @@ -349,12 +349,10 @@ size_t WadFile::lumpSize(int lumpIdx) AutoStr* WadFile::composeLumpPath(int lumpIdx, char delimiter) { - PathDirectoryNode* node = lumpDirectoryNode(lumpIdx); - if(node) - { - return node->composePath(AutoStr_NewStd(), NULL, delimiter); - } - return AutoStr_NewStd(); + if(!isValidIndex(lumpIdx)) return AutoStr_NewStd(); + + PathDirectoryNode& node = lumpDirectoryNode(lumpIdx); + return node.composePath(AutoStr_NewStd(), NULL, delimiter); } int WadFile::publishLumpsToIndex(LumpIndex& index) @@ -405,15 +403,14 @@ uint8_t const* WadFile::cacheLump(int lumpIdx) { LOG_AS("WadFile::cacheLump"); - if(!isValidIndex(lumpIdx)) - throw Error("WadFile::cacheLump", invalidIndexMessage(lumpIdx, lastIndex())); + if(!isValidIndex(lumpIdx)) throw Error("WadFile::cacheLump", invalidIndexMessage(lumpIdx, lastIndex())); - const LumpInfo* info = lumpInfo(lumpIdx); + LumpInfo const& info = lumpInfo(lumpIdx); LOG_TRACE("\"%s:%s\" (%lu bytes%s)") << F_PrettyPath(Str_Text(path())) << F_PrettyPath(Str_Text(composeLumpPath(lumpIdx, '/'))) - << (unsigned long) info->size - << (info->compressedSize != info->size? ", compressed" : ""); + << (unsigned long) info.size + << (info.compressedSize != info.size? ", compressed" : ""); // Time to create the cache? if(!d->lumpCache) @@ -424,8 +421,8 @@ uint8_t const* WadFile::cacheLump(int lumpIdx) uint8_t const* data = d->lumpCache->data(lumpIdx); if(data) return data; - uint8_t* region = (uint8_t*) Z_Malloc(info->size, PU_APPSTATIC, 0); - if(!region) throw Error("WadFile::cacheLump", QString("Failed on allocation of %1 bytes for cache copy of lump #%2").arg(info->size).arg(lumpIdx)); + uint8_t* region = (uint8_t*) Z_Malloc(info.size, PU_APPSTATIC, 0); + if(!region) throw Error("WadFile::cacheLump", QString("Failed on allocation of %1 bytes for cache copy of lump #%2").arg(info.size).arg(lumpIdx)); readLump(lumpIdx, region, false); d->lumpCache->insert(lumpIdx, region); @@ -461,9 +458,8 @@ WadFile& WadFile::unlockLump(int lumpIdx) size_t WadFile::readLump(int lumpIdx, uint8_t* buffer, bool tryCache) { LOG_AS("WadFile::readLump"); - LumpInfo const* info = lumpInfo(lumpIdx); - if(!info) return 0; - return readLump(lumpIdx, buffer, 0, info->size, tryCache); + if(!isValidIndex(lumpIdx)) return 0; + return readLump(lumpIdx, buffer, 0, lumpInfo(lumpIdx).size, tryCache); } size_t WadFile::readLump(int lumpIdx, uint8_t* buffer, size_t startOffset, diff --git a/doomsday/engine/portable/src/zipfile.cpp b/doomsday/engine/portable/src/zipfile.cpp index 667dc44c41..2728f8a2f1 100644 --- a/doomsday/engine/portable/src/zipfile.cpp +++ b/doomsday/engine/portable/src/zipfile.cpp @@ -500,13 +500,6 @@ bool ZipFile::empty() return !lumpCount(); } -PathDirectoryNode* ZipFile::lumpDirectoryNode(int lumpIdx) -{ - if(!isValidIndex(lumpIdx)) return NULL; - d->buildLumpNodeLut(); - return (*d->lumpNodeLut)[lumpIdx]; -} - static QString invalidIndexMessage(int invalidIdx, int lastValidIdx) { QString msg = QString("Invalid lump index %1 ").arg(invalidIdx); @@ -515,12 +508,19 @@ static QString invalidIndexMessage(int invalidIdx, int lastValidIdx) return msg; } -LumpInfo const* ZipFile::lumpInfo(int lumpIdx) +PathDirectoryNode& ZipFile::lumpDirectoryNode(int lumpIdx) +{ + if(!isValidIndex(lumpIdx)) throw Error("ZipFile::lumpDirectoryNode", invalidIndexMessage(lumpIdx, lastIndex())); + d->buildLumpNodeLut(); + return *((*d->lumpNodeLut)[lumpIdx]); +} + +LumpInfo const& ZipFile::lumpInfo(int lumpIdx) { LOG_AS("ZipFile"); ZipLumpRecord* lrec = d->lumpRecord(lumpIdx); if(!lrec) throw Error("ZipFile::lumpInfo", invalidIndexMessage(lumpIdx, lastIndex())); - return &lrec->info; + return lrec->info; } size_t ZipFile::lumpSize(int lumpIdx) @@ -533,12 +533,9 @@ size_t ZipFile::lumpSize(int lumpIdx) AutoStr* ZipFile::composeLumpPath(int lumpIdx, char delimiter) { - PathDirectoryNode* node = lumpDirectoryNode(lumpIdx); - if(node) - { - return node->composePath(AutoStr_NewStd(), NULL, delimiter); - } - return AutoStr_NewStd(); + if(!isValidIndex(lumpIdx)) return AutoStr_NewStd(); + PathDirectoryNode& node = lumpDirectoryNode(lumpIdx); + return node.composePath(AutoStr_NewStd(), NULL, delimiter); } int ZipFile::publishLumpsToIndex(LumpIndex& index) @@ -589,15 +586,14 @@ uint8_t const* ZipFile::cacheLump(int lumpIdx) { LOG_AS("ZipFile::cacheLump"); - if(!isValidIndex(lumpIdx)) - throw Error("ZipFile::cacheLump", invalidIndexMessage(lumpIdx, lastIndex())); + if(!isValidIndex(lumpIdx)) throw Error("ZipFile::cacheLump", invalidIndexMessage(lumpIdx, lastIndex())); - const LumpInfo* info = lumpInfo(lumpIdx); + LumpInfo const& info = lumpInfo(lumpIdx); LOG_TRACE("\"%s:%s\" (%lu bytes%s)") << F_PrettyPath(Str_Text(path())) << F_PrettyPath(Str_Text(composeLumpPath(lumpIdx, '/'))) - << (unsigned long) info->size - << (info->compressedSize != info->size? ", compressed" : ""); + << (unsigned long) info.size + << (info.compressedSize != info.size? ", compressed" : ""); // Time to create the cache? if(!d->lumpCache) @@ -608,8 +604,8 @@ uint8_t const* ZipFile::cacheLump(int lumpIdx) uint8_t const* data = d->lumpCache->data(lumpIdx); if(data) return data; - uint8_t* region = (uint8_t*) Z_Malloc(info->size, PU_APPSTATIC, 0); - if(!region) throw Error("ZipFile::cacheLump", QString("Failed on allocation of %1 bytes for cache copy of lump #%2").arg(info->size).arg(lumpIdx)); + uint8_t* region = (uint8_t*) Z_Malloc(info.size, PU_APPSTATIC, 0); + if(!region) throw Error("ZipFile::cacheLump", QString("Failed on allocation of %1 bytes for cache copy of lump #%2").arg(info.size).arg(lumpIdx)); readLump(lumpIdx, region, false); d->lumpCache->insert(lumpIdx, region); @@ -645,9 +641,8 @@ ZipFile& ZipFile::unlockLump(int lumpIdx) size_t ZipFile::readLump(int lumpIdx, uint8_t* buffer, bool tryCache) { LOG_AS("ZipFile::readLump"); - LumpInfo const* info = lumpInfo(lumpIdx); - if(!info) return 0; - return readLump(lumpIdx, buffer, 0, info->size, tryCache); + if(!isValidIndex(lumpIdx)) return 0; + return readLump(lumpIdx, buffer, 0, lumpInfo(lumpIdx).size, tryCache); } size_t ZipFile::readLump(int lumpIdx, uint8_t* buffer, size_t startOffset,