From 0ea5fc66924303d1bf73ba283a383e2aadee02f2 Mon Sep 17 00:00:00 2001 From: neodarz Date: Sat, 11 Aug 2018 20:21:34 +0200 Subject: Initial commit --- docs/doxygen/nel/a02261.html | 791 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 791 insertions(+) create mode 100644 docs/doxygen/nel/a02261.html (limited to 'docs/doxygen/nel/a02261.html') diff --git a/docs/doxygen/nel/a02261.html b/docs/doxygen/nel/a02261.html new file mode 100644 index 00000000..c09dd0e9 --- /dev/null +++ b/docs/doxygen/nel/a02261.html @@ -0,0 +1,791 @@ + + +NeL: NLMISC::CBigFile class Reference + + + +
+Main Page | Namespace List | Class Hierarchy | Alphabetical List | Data Structures | File List | Namespace Members | Data Fields | Globals | Related Pages | Search for 
+

NLMISC::CBigFile Class Reference

#include <big_file.h> +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Public Member Functions

bool add (const std::string &sBigFileName, uint32 nOptions)
FILE * getFile (const std::string &sFileName, uint32 &rFileSize, uint32 &rBigFileOffset, bool &rCacheFileOnOpen, bool &rAlwaysOpened)
char * getFileNamePtr (const std::string &sFileName, const std::string &sBigFileName)
bool isBigFileAdded (const std::string &sBigFileName)
void list (const std::string &sBigFileName, std::vector< std::string > &vAllFiles)
void remove (const std::string &sBigFileName)
void removeAll ()

Static Public Member Functions

CBigFile & getInstance ()

Private Member Functions

 CBigFile ()

Private Attributes

std::map< std::string, BNP > _BNPs
CThreadFileArray _ThreadFileArray

Static Private Attributes

CBigFile * _Singleton = NULL

Friends

class CThreadFileArray
+

Constructor & Destructor Documentation

+

+ + + + +
+ + + + + + + + + +
NLMISC::CBigFile::CBigFile (   )  [private]
+
+ + + + + +
+   + + +

+ +

+Definition at line 71 of file big_file.cpp. +

+Referenced by getInstance(). +

+

00072 {
+00073 }
+
+

Member Function Documentation

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
bool NLMISC::CBigFile::add ( const std::string &  sBigFileName,
uint32  nOptions
) 
+
+ + + + + +
+   + + +

+ +

+Definition at line 86 of file big_file.cpp. +

+References _BNPs, _ThreadFileArray, NLMISC::CBigFile::CThreadFileArray::allocate(), NLMISC::CBigFile::BNP::AlwaysOpened, NLMISC::BF_ALWAYS_OPENED, NLMISC::BF_CACHE_FILE_ON_OPEN, NLMISC::CBigFile::BNP::BigFileName, NLMISC::CBigFile::BNP::CacheFileOnOpen, NLMISC::CBigFile::CHandleFile::File, NLMISC::CBigFile::BNP::FileNames, NLMISC::CBigFile::BNP::Files, NLMISC::CBigFile::CThreadFileArray::get(), NLMISC::nlfseek64(), nlwarning, NLMISC::CBigFile::BNPFile::Pos, NLMISC::CBigFile::BNPFile::Size, NLMISC::strlwr(), NLMISC::CBigFile::BNP::ThreadFileId, uint, uint32, and uint8. +

+

00087 {
+00088         BNP bnpTmp;
+00089 
+00090         bnpTmp.BigFileName= sBigFileName;
+00091 
+00092         // Is already the same bigfile name ?
+00093         string bigfilenamealone = CFile::getFilename (sBigFileName);
+00094         if (_BNPs.find(bigfilenamealone) != _BNPs.end())
+00095         {
+00096                 nlwarning ("CBigFile::add : bigfile %s already added.", bigfilenamealone.c_str());
+00097                 return false;
+00098         }
+00099 
+00100         // Allocate a new ThreadSafe FileId for this bnp.
+00101         bnpTmp.ThreadFileId= _ThreadFileArray.allocate();
+00102 
+00103         // Get a ThreadSafe handle on the file
+00104         CHandleFile             &handle= _ThreadFileArray.get(bnpTmp.ThreadFileId);
+00105         // Open the big file.
+00106         handle.File = fopen (sBigFileName.c_str(), "rb");
+00107         if (handle.File == NULL)
+00108                 return false;
+00109         uint32 nFileSize=CFile::getFileSize (handle.File);
+00110         //nlfseek64 (handle.File, 0, SEEK_END);
+00111         //uint32 nFileSize = ftell (handle.File);
+00112 
+00113         // Result
+00114         if (nlfseek64 (handle.File, nFileSize-4, SEEK_SET) != 0)
+00115                 return false;
+00116 
+00117         uint32 nOffsetFromBegining;
+00118         if (fread (&nOffsetFromBegining, sizeof(uint32), 1, handle.File) != 1)
+00119                 return false;
+00120 
+00121         if (nlfseek64 (handle.File, nOffsetFromBegining, SEEK_SET) != 0)
+00122                 return false;
+00123 
+00124         // Read the file count
+00125         uint32 nNbFile;
+00126         if (fread (&nNbFile, sizeof(uint32), 1, handle.File) != 1)
+00127                 return false;
+00128         map<string,BNPFile> tempMap;
+00129         for (uint32 i = 0; i < nNbFile; ++i)
+00130         {
+00131                 char FileName[256];
+00132                 uint8 nStringSize;
+00133                 if (fread (&nStringSize, 1, 1, handle.File) != 1)
+00134                         return false;
+00135                 
+00136                 if (fread (FileName, 1, nStringSize, handle.File) != nStringSize)
+00137                         return false;
+00138 
+00139                 FileName[nStringSize] = 0;
+00140                 uint32 nFileSize2;
+00141                 if (fread (&nFileSize2, sizeof(uint32), 1, handle.File) != 1)
+00142                         return false;
+00143 
+00144                 uint32 nFilePos;
+00145                 if (fread (&nFilePos, sizeof(uint32), 1, handle.File) != 1)
+00146                         return false;
+00147 
+00148                 BNPFile bnpfTmp;
+00149                 bnpfTmp.Pos = nFilePos;
+00150                 bnpfTmp.Size = nFileSize2;
+00151                 tempMap.insert (make_pair(strlwr(string(FileName)), bnpfTmp));
+00152         }
+00153 
+00154         if (nlfseek64 (handle.File, 0, SEEK_SET) != 0)
+00155                 return false;
+00156 
+00157         // Convert temp map
+00158         if (nNbFile > 0)
+00159         {
+00160                 uint nSize = 0, nNb = 0;
+00161                 map<string,BNPFile>::iterator it = tempMap.begin();
+00162                 while (it != tempMap.end())
+00163                 {
+00164                         nSize += it->first.size() + 1;
+00165                         nNb++;
+00166                         it++;
+00167                 }
+00168 
+00169                 bnpTmp.FileNames = new char[nSize];
+00170                 memset(bnpTmp.FileNames, 0, nSize);
+00171                 bnpTmp.Files.resize(nNb);
+00172 
+00173                 it = tempMap.begin();
+00174                 nSize = 0;
+00175                 nNb = 0;
+00176                 while (it != tempMap.end())
+00177                 {
+00178                         strcpy(bnpTmp.FileNames+nSize, it->first.c_str());
+00179                         
+00180                         bnpTmp.Files[nNb].Name = bnpTmp.FileNames+nSize;
+00181                         bnpTmp.Files[nNb].Size = it->second.Size;
+00182                         bnpTmp.Files[nNb].Pos = it->second.Pos;
+00183 
+00184                         nSize += it->first.size() + 1;
+00185                         nNb++;
+00186                         it++;
+00187                 }
+00188         }
+00189         // End of temp map conversion
+00190 
+00191         if (nOptions&BF_CACHE_FILE_ON_OPEN)
+00192                 bnpTmp.CacheFileOnOpen = true;
+00193         else
+00194                 bnpTmp.CacheFileOnOpen = false;
+00195 
+00196         if (!(nOptions&BF_ALWAYS_OPENED))
+00197         {
+00198                 fclose (handle.File);
+00199                 handle.File = NULL;
+00200                 bnpTmp.AlwaysOpened = false;
+00201         }
+00202         else
+00203         {
+00204                 bnpTmp.AlwaysOpened = true;
+00205         }
+00206 
+00207         _BNPs.insert (make_pair(strlwr(bigfilenamealone), bnpTmp));
+00208 
+00209         return true;
+00210 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
FILE * NLMISC::CBigFile::getFile ( const std::string &  sFileName,
uint32 &  rFileSize,
uint32 &  rBigFileOffset,
bool &  rCacheFileOnOpen,
bool &  rAlwaysOpened
) 
+
+ + + + + +
+   + + +

+ +

+Definition at line 273 of file big_file.cpp. +

+References _BNPs, _ThreadFileArray, NLMISC::CBigFile::BNP::AlwaysOpened, NLMISC::CBigFile::BNP::BigFileName, NLMISC::CBigFile::BNP::CacheFileOnOpen, NLMISC::CBigFile::CHandleFile::File, NLMISC::CBigFile::BNP::Files, NLMISC::CBigFile::CThreadFileArray::get(), nlwarning, NLMISC::CBigFile::BNPFile::Pos, NLMISC::CBigFile::BNPFile::Size, NLMISC::strlwr(), NLMISC::CBigFile::BNP::ThreadFileId, and uint32. +

+

00275 {
+00276         string zeFileName, zeBigFileName, lwrFileName = strlwr (sFileName);
+00277         uint32 i, nPos = sFileName.find ('@');
+00278         if (nPos == string::npos)
+00279         {
+00280                 nlwarning ("BF: Couldn't load '%s'", sFileName.c_str());
+00281                 return NULL;
+00282         }
+00283 
+00284         for (i = 0; i < nPos; ++i)
+00285                 zeBigFileName += lwrFileName[i];
+00286         ++i; // Skip @
+00287         for (; i < lwrFileName.size(); ++i)
+00288                 zeFileName += lwrFileName[i];
+00289 
+00290         if (_BNPs.find (zeBigFileName) == _BNPs.end())
+00291         {
+00292                 nlwarning ("BF: Couldn't load '%s'", sFileName.c_str());
+00293                 return NULL;
+00294         }
+00295 
+00296         BNP &rbnp = _BNPs.find (zeBigFileName)->second;
+00297         if (rbnp.Files.size() == 0)
+00298         {
+00299                 nlwarning ("BF: Couldn't load '%s'", sFileName.c_str());
+00300                 return NULL;
+00301         }
+00302 
+00303         vector<BNPFile>::iterator itNBPFile;
+00304         itNBPFile = lower_bound(rbnp.Files.begin(), rbnp.Files.end(), zeFileName.c_str(), CBNPFileComp());
+00305         if (itNBPFile != rbnp.Files.end())
+00306         {
+00307                 if (strcmp(itNBPFile->Name, zeFileName.c_str()) != 0)
+00308                 {
+00309                         nlwarning ("BF: Couldn't load '%s'", sFileName.c_str());
+00310                         return NULL;
+00311                 }
+00312         }
+00313         else
+00314         {
+00315                 nlwarning ("BF: Couldn't load '%s'", sFileName.c_str());
+00316                 return NULL;
+00317         }
+00318 
+00319         BNPFile &rbnpfile = *itNBPFile;
+00320 
+00321         // Get a ThreadSafe handle on the file
+00322         CHandleFile             &handle= _ThreadFileArray.get(rbnp.ThreadFileId);
+00323         /* If not opened, open it now. There is 2 reason for it to be not opened: 
+00324                 rbnp.AlwaysOpened==false, or it is a new thread which use it for the first time.
+00325         */
+00326         if(handle.File== NULL)
+00327         {
+00328                 handle.File = fopen (rbnp.BigFileName.c_str(), "rb");
+00329                 if (handle.File == NULL)
+00330                         return NULL;
+00331         }
+00332 
+00333         rCacheFileOnOpen = rbnp.CacheFileOnOpen;
+00334         rAlwaysOpened = rbnp.AlwaysOpened;
+00335         rBigFileOffset = rbnpfile.Pos;
+00336         rFileSize = rbnpfile.Size;
+00337         return handle.File;
+00338 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
char * NLMISC::CBigFile::getFileNamePtr ( const std::string &  sFileName,
const std::string &  sBigFileName
) 
+
+ + + + + +
+   + + +

+ +

+Definition at line 341 of file big_file.cpp. +

+References _BNPs, NLMISC::CBigFile::BNP::Files, and NLMISC::strlwr(). +

+

00342 {
+00343         string bigfilenamealone = CFile::getFilename (sBigFileName);
+00344         if (_BNPs.find(bigfilenamealone) != _BNPs.end())
+00345         {
+00346                 BNP &rbnp = _BNPs.find (bigfilenamealone)->second;
+00347                 vector<BNPFile>::iterator itNBPFile;
+00348                 if (rbnp.Files.size() == 0)
+00349                         return NULL;
+00350                 string lwrFileName = strlwr (sFileName);
+00351                 itNBPFile = lower_bound(rbnp.Files.begin(), rbnp.Files.end(), lwrFileName.c_str(), CBNPFileComp());
+00352                 if (itNBPFile != rbnp.Files.end())
+00353                 {
+00354                         if (strcmp(itNBPFile->Name, lwrFileName.c_str()) == 0)
+00355                         {
+00356                                 return itNBPFile->Name;
+00357                         }
+00358                 }
+00359         }
+00360 
+00361         return NULL;
+00362 }
+
+

+ + + + +
+ + + + + + + + + +
CBigFile & NLMISC::CBigFile::getInstance (   )  [static]
+
+ + + + + +
+   + + +

+ +

+Definition at line 76 of file big_file.cpp. +

+References CBigFile(). +

+

00077 {
+00078         if (_Singleton == NULL)
+00079         {
+00080                 _Singleton = new CBigFile();
+00081         }
+00082         return *_Singleton;
+00083 }
+
+

+ + + + +
+ + + + + + + + + + +
bool NLMISC::CBigFile::isBigFileAdded ( const std::string &  sBigFileName  ) 
+
+ + + + + +
+   + + +

+ +

+Definition at line 240 of file big_file.cpp. +

+References _BNPs. +

+

00241 {
+00242         // Is already the same bigfile name ?
+00243         string bigfilenamealone = CFile::getFilename (sBigFileName);
+00244         return _BNPs.find(bigfilenamealone) != _BNPs.end();
+00245 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NLMISC::CBigFile::list ( const std::string &  sBigFileName,
std::vector< std::string > &  vAllFiles
) 
+
+ + + + + +
+   + + +

+ +

+Definition at line 248 of file big_file.cpp. +

+References _BNPs, NLMISC::CBigFile::BNP::Files, and NLMISC::strlwr(). +

+

00249 {
+00250         string lwrFileName = strlwr (sBigFileName);
+00251         if (_BNPs.find (lwrFileName) == _BNPs.end())
+00252                 return;
+00253         vAllFiles.clear ();
+00254         BNP &rbnp = _BNPs.find (lwrFileName)->second;
+00255         vector<BNPFile>::iterator it = rbnp.Files.begin();
+00256         while (it != rbnp.Files.end())
+00257         {
+00258                 vAllFiles.push_back (string(it->Name)); // Add the name of the file to the return vector
+00259                 ++it;
+00260         }
+00261 }
+
+

+ + + + +
+ + + + + + + + + + +
void NLMISC::CBigFile::remove ( const std::string &  sBigFileName  ) 
+
+ + + + + +
+   + + +

+ +

+Definition at line 213 of file big_file.cpp. +

+References _BNPs, _ThreadFileArray, NLMISC::CBigFile::CHandleFile::File, NLMISC::CBigFile::BNP::FileNames, NLMISC::CBigFile::CThreadFileArray::get(), and NLMISC::CBigFile::BNP::ThreadFileId. +

+Referenced by removeAll(). +

+

00214 {
+00215         if (_BNPs.find (sBigFileName) != _BNPs.end())
+00216         {
+00217                 map<string, BNP>::iterator it = _BNPs.find (sBigFileName);
+00218                 BNP &rbnp = it->second;
+00219                 /* \todo yoyo: THERE is a MAJOR drawback here: Only the FILE * of the current (surely main) thread
+00220                         is closed. other FILE* in other threads are still opened. This is not a big issue (system close the FILE* 
+00221                         at the end of the process) and this is important so AsyncLoading of a currentTask can end up correclty 
+00222                         (without an intermediate fclose()).
+00223                 */
+00224                 // Get a ThreadSafe handle on the file
+00225                 CHandleFile             &handle= _ThreadFileArray.get(rbnp.ThreadFileId);
+00226                 // close it if needed
+00227                 if (handle.File != NULL)
+00228                 {
+00229                         fclose (handle.File);
+00230                         handle.File= NULL;
+00231                 }
+00232                 /* \todo trap : can make the CPath crash. CPath must be informed that the files in bigfiles have been removed
+00233                         this is because CPath use memory of CBigFile if it runs in memoryCompressed mode */
+00234                 delete [] rbnp.FileNames;
+00235                 _BNPs.erase (it);
+00236         }
+00237 }
+
+

+ + + + +
+ + + + + + + + + +
void NLMISC::CBigFile::removeAll (   ) 
+
+ + + + + +
+   + + +

+ +

+Definition at line 264 of file big_file.cpp. +

+References _BNPs, and remove(). +

+

00265 {
+00266         while (_BNPs.begin() != _BNPs.end())
+00267         {
+00268                 remove (_BNPs.begin()->first);
+00269         }
+00270 }
+
+

Friends And Related Function Documentation

+

+ + + + +
+ + +
friend class CThreadFileArray [friend] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 79 of file big_file.h.

+

Field Documentation

+

+ + + + +
+ + +
std::map<std::string, BNP> NLMISC::CBigFile::_BNPs [private] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 153 of file big_file.h. +

+Referenced by add(), getFile(), getFileNamePtr(), isBigFileAdded(), list(), remove(), and removeAll().

+

+ + + + +
+ + +
CBigFile * NLMISC::CBigFile::_Singleton = NULL [static, private] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 36 of file big_file.cpp.

+

+ + + + +
+ + +
CThreadFileArray NLMISC::CBigFile::_ThreadFileArray [private] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 151 of file big_file.h. +

+Referenced by add(), getFile(), and remove().

+

The documentation for this class was generated from the following files: +
Generated on Tue Mar 16 13:02:12 2004 for NeL by + +doxygen +1.3.6
+ + -- cgit v1.2.1