Refactor: Renamed LumpFile as LumpFileAdaptor

doomsday/engine/engine.pro

@@ -240,7 +240,7 @@ DENG_HEADERS += \
     portable/include/library.h \
     portable/include/linedef.h \
     portable/include/lumpcache.h \
-    portable/include/lumpfile.h \
+    portable/include/lumpfileadaptor.h \
     portable/include/lumpindex.h \
     portable/include/m_bams.h \
     portable/include/m_decomp64.h \
@@ -529,7 +529,7 @@ SOURCES += \
     portable/src/keycode.cpp \
     portable/src/library.c \
     portable/src/linedef.c \
-    portable/src/lumpfile.cpp \
+    portable/src/lumpfileadaptor.cpp \
     portable/src/lumpindex.cpp \
     portable/src/m_bams.c \
     portable/src/m_decomp64.c \

doomsday/engine/portable/include/fs_main.h

@@ -433,7 +433,7 @@ boolean F_IsValidLumpNum(lumpnum_t absoluteLumpNum);
 
 lumpnum_t F_LumpNumForName(char const* name);
 
-ddstring_t const* F_LumpFilePath(lumpnum_t absoluteLumpNum);
+ddstring_t const* F_LumpFileAdaptorPath(lumpnum_t absoluteLumpNum);
 
 boolean F_LumpIsCustom(lumpnum_t absoluteLumpNum);
 

doomsday/engine/portable/include/lumpfile.h → doomsday/engine/portable/include/lumpfileadaptor.h

@@ -1,12 +1,12 @@
 /**
- * @file lumpfile.h
+ * @file lumpfileadaptor.h
  *
  * Specialization of AbstractFile for working with the lumps of container
  * file instances (such as Wad and Zip).
  *
- * Design wise a LumpFile is somewhat like an Adapter or Bridge, in that it
- * provides an AbstractFile-derived object instance through which a lump of
- * a contained file may be manipulated.
+ * Design wise a LumpFileAdaptorAdaptor is an Adapter, in that it provides an
+ * AbstractFile-derived object instance through which a lump of a contained
+ * file may be manipulated.
  *
  * @ingroup fs
  *
@@ -30,8 +30,8 @@
  * 02110-1301 USA</small>
  */
 
-#ifndef LIBDENG_FILESYS_LUMPFILE_H
-#define LIBDENG_FILESYS_LUMPFILE_H
+#ifndef LIBDENG_FILESYS_LUMPFILEADAPTOR_H
+#define LIBDENG_FILESYS_LUMPFILEADAPTOR_H
 
 #ifdef __cplusplus
 
@@ -45,13 +45,14 @@ class LumpIndex;
 class PathDirectoryNode;
 
 /**
- * LumpFile. Runtime representation of a lump-file.
+ * LumpFileAdaptor. AbstractFile adaptor class allowing lumps to be interfaced with as
+ * if they were "real" files.
  */
-class LumpFile : public AbstractFile
+class LumpFileAdaptor : public AbstractFile
 {
 public:
-    LumpFile(DFile& file, char const* path, FileInfo const& info);
-    ~LumpFile();
+    LumpFileAdaptor(DFile& file, char const* path, FileInfo const& info);
+    ~LumpFileAdaptor();
 
     /**
      * Retrieve the directory node for a lump contained by this file.
@@ -131,7 +132,7 @@ class LumpFile : public AbstractFile
      *
      * @return This instance.
      */
-    LumpFile& unlockLump(int lumpIdx);
+    LumpFileAdaptor& unlockLump(int lumpIdx);
 
 private:
     struct Instance;
@@ -143,11 +144,11 @@ class LumpFile : public AbstractFile
 extern "C" {
 #endif // __cplusplus
 
-struct lumpfile_s; // The lumpfile instance (opaque)
-//typedef struct lumpfile_s LumpFile;
+struct lumpfileadaptor_s; // The lumpfileadaptor instance (opaque)
+//typedef struct lumpfileadaptor_s LumpFileAdaptor;
 
 #ifdef __cplusplus
 } // extern "C"
 #endif
 
-#endif /* LIBDENG_FILESYS_LUMPFILE_H */
+#endif /* LIBDENG_FILESYS_LUMPFILEADAPTOR_H */

doomsday/engine/portable/src/dam_main.c

@@ -256,7 +256,7 @@ boolean DAM_AttemptMapLoad(const Uri* uri)
         if(0 > markerLump) return false;
 
         // Compose the cache directory path and ensure it exists.
-        cachedMapDir = DAM_ComposeCacheDir(Str_Text(F_LumpFilePath(markerLump)));
+        cachedMapDir = DAM_ComposeCacheDir(Str_Text(F_LumpFileAdaptorPath(markerLump)));
         F_MakePath(Str_Text(cachedMapDir));
 
         // Compose the full path to the cached map data file.

doomsday/engine/portable/src/edit_map.c

@@ -1724,7 +1724,7 @@ boolean MPE_End(void)
     {
         // Yes, write the cached map data file.
         lumpnum_t markerLumpNum = F_LumpNumForName(Str_Text(Uri_Path(gamemap->uri)));
-        AutoStr* cachedMapDir = DAM_ComposeCacheDir(Str_Text(F_LumpFilePath(markerLumpNum)));
+        AutoStr* cachedMapDir = DAM_ComposeCacheDir(Str_Text(F_LumpFileAdaptorPath(markerLumpNum)));
         Str cachedMapPath;
 
         Str_InitStd(&cachedMapPath);

doomsday/engine/portable/src/fs_main.cpp

@@ -36,7 +36,7 @@
 #include "genericfile.h"
 #include "lumpindex.h"
 #include "fileinfo.h"
-#include "lumpfile.h"
+#include "lumpfileadaptor.h"
 #include "m_misc.h" // for M_FindWhite()
 #include "wad.h"
 #include "zip.h"
@@ -467,7 +467,7 @@ void FS1::index(de::AbstractFile& file)
         index.catalogLumps(*wad, 0, wad->lumpCount());
         return;
     }
-    if(LumpFile* lump = dynamic_cast<LumpFile*>(&file))
+    if(LumpFileAdaptor* lump = dynamic_cast<LumpFileAdaptor*>(&file))
     {
         LumpIndex& index = *d->ActiveWadLumpIndex;
         // This *is* the lump, so insert ourself as a lump of our container in the index.
@@ -1118,10 +1118,10 @@ de::AbstractFile& FS1::interpret(de::DFile& hndl, char const* path, FileInfo con
     // Still not interpreted?
     if(!interpretedFile)
     {
-        // Use a generic file - LumpFile for contained lumps else GenericFile.
+        // Use a generic file - LumpFileAdaptor for contained lumps else GenericFile.
         if(info.container)
         {
-            interpretedFile = new LumpFile(hndl, path, info);
+            interpretedFile = new LumpFileAdaptor(hndl, path, info);
         }
         else
         {
@@ -1157,7 +1157,7 @@ de::DFile& FS1::openLump(lumpnum_t absoluteLumpNum)
 {
     int lumpIdx;
     de::AbstractFile& container = lumpFile(absoluteLumpNum, &lumpIdx);
-    LumpFile* lump = new LumpFile(*DFileBuilder::fromFileLump(container, lumpIdx, false),
+    LumpFileAdaptor* lump = new LumpFileAdaptor(*DFileBuilder::fromFileLump(container, lumpIdx, false),
                                   Str_Text(container.composeLumpPath(lumpIdx)),
                                   container.lumpInfo(lumpIdx));
     DENG_ASSERT(lump);
@@ -1965,7 +1965,7 @@ struct abstractfile_s* F_FindFileForLumpNum(lumpnum_t absoluteLumpNum)
     return 0;
 }
 
-ddstring_t const* F_LumpFilePath(lumpnum_t absoluteLumpNum)
+ddstring_t const* F_LumpFileAdaptorPath(lumpnum_t absoluteLumpNum)
 {
     try
     {

doomsday/engine/portable/src/lumpfile.cpp → doomsday/engine/portable/src/lumpfileadaptor.cpp

@@ -21,55 +21,55 @@
  */
 
 #include "lumpindex.h"
-#include "lumpfile.h"
+#include "lumpfileadaptor.h"
 
 namespace de {
 
-LumpFile::LumpFile(DFile& file, char const* path, FileInfo const& info)
+LumpFileAdaptor::LumpFileAdaptor(DFile& file, char const* path, FileInfo const& info)
     : AbstractFile(FT_LUMPFILE, path, file, info)
 {}
 
-LumpFile::~LumpFile()
+LumpFileAdaptor::~LumpFileAdaptor()
 {}
 
-de::PathDirectoryNode const& LumpFile::lumpDirectoryNode(int /*lumpIdx*/)
+de::PathDirectoryNode const& LumpFileAdaptor::lumpDirectoryNode(int /*lumpIdx*/)
 {
     // Lump files are special cases for this *is* the lump.
     return container().lumpDirectoryNode(info().lumpIdx);
 }
 
-AutoStr* LumpFile::composeLumpPath(int /*lumpIdx*/, char delimiter)
+AutoStr* LumpFileAdaptor::composeLumpPath(int /*lumpIdx*/, char delimiter)
 {
     // Lump files are special cases for this *is* the lump.
     return container().composeLumpPath(info().lumpIdx, delimiter);
 }
 
-size_t LumpFile::lumpSize(int /*lumpIdx*/)
+size_t LumpFileAdaptor::lumpSize(int /*lumpIdx*/)
 {
     // Lump files are special cases for this *is* the lump.
     return info().size;
 }
 
-size_t LumpFile::readLump(int /*lumpIdx*/, uint8_t* buffer, bool tryCache)
+size_t LumpFileAdaptor::readLump(int /*lumpIdx*/, uint8_t* buffer, bool 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 LumpFileAdaptor::readLump(int /*lumpIdx*/, uint8_t* buffer, size_t startOffset,
     size_t length, bool 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* LumpFileAdaptor::cacheLump(int /*lumpIdx*/)
 {
     // Lump files are special cases for this *is* the lump.
     return container().cacheLump(info().lumpIdx);
 }
 
-LumpFile& LumpFile::unlockLump(int /*lumpIdx*/)
+LumpFileAdaptor& LumpFileAdaptor::unlockLump(int /*lumpIdx*/)
 {
     // Lump files are special cases for this *is* the lump.
     container().unlockLump(info().lumpIdx);