nevrax.org : docs

00001 
+00007 /* Copyright, 2001 Nevrax Ltd.
+00008  *
+00009  * This file is part of NEVRAX NEL.
+00010  * NEVRAX NEL is free software; you can redistribute it and/or modify
+00011  * it under the terms of the GNU General Public License as published by
+00012  * the Free Software Foundation; either version 2, or (at your option)
+00013  * any later version.
+00014 
+00015  * NEVRAX NEL is distributed in the hope that it will be useful, but
+00016  * WITHOUT ANY WARRANTY; without even the implied warranty of
+00017  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+00018  * General Public License for more details.
+00019 
+00020  * You should have received a copy of the GNU General Public License
+00021  * along with NEVRAX NEL; see the file COPYING. If not, write to the
+00022  * Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
+00023  * MA 02111-1307, USA.
+00024  */
+00025 
+00026 #ifndef NL_LOAD_FORM_H
+00027 #define NL_LOAD_FORM_H
+00028 
+00029 #include "nel/misc/types_nl.h"
+00030 
+00031 #include <map>
+00032 #include <string>
+00033 #include <vector>
+00034 
+00035 #include "nel/misc/path.h"
+00036 #include "nel/misc/file.h"
+00037 
+00038 #include "nel/georges/u_form_loader.h"
+00039 #include "nel/georges/u_form.h"
+00040 #include "nel/misc/sheet_id.h"
+00041 
+00099 template <class T>
+00100 void loadForm (const std::string &sheetFilter, const std::string &packedFilename, std::map<NLMISC::CSheetId, T> &container, bool updatePackedSheet=true)
+00101 {
+00102         std::vector<std::string> vs;
+00103         vs.push_back(sheetFilter);
+00104         loadForm(vs, packedFilename, container, updatePackedSheet);
+00105 }
+00106 
+00112 template <class T>
+00113 void loadForm (const std::vector<std::string> &sheetFilters, const std::string &packedFilename, std::map<NLMISC::CSheetId, T> &container, bool updatePackedSheet=true)
+00114 {
+00115         // check the extension (i know that file like "foo.packed_sheetsbar" will be accepted but this check is enough...)
+00116         nlassert (packedFilename.find (".packed_sheets") != std::string::npos);
+00117 
+00118         std::string packedFilenamePath = NLMISC::CPath::lookup(packedFilename, false);
+00119         if (packedFilenamePath.empty())
+00120         {
+00121                 packedFilenamePath = packedFilename;
+00122         }
+00123 
+00124         // make sure the CSheetId singleton has been properly initialised
+00125         NLMISC::CSheetId::init(updatePackedSheet);
+00126 
+00127         bool olde, newe;
+00128         NLMISC::CIFile::getVersionException(olde, newe);
+00129         // load the packed sheet if exists
+00130         try
+00131         {
+00132                 NLMISC::CIFile ifile;
+00133                 ifile.setCacheFileOnOpen(true);
+00134                 ifile.open (packedFilenamePath);
+00135                 // an exception will be launch if the file is not the good version or if the file is not found
+00136 
+00137                 nlinfo ("loadForm(): Loading packed file '%s'", packedFilename.c_str());
+00138                 
+00139                 uint32 nbEntries;
+00140                 ifile.serial (nbEntries);
+00141                 ifile.setVersionException (true, true);
+00142                 uint ver = T::getVersion ();
+00143                 ifile.serialVersion(ver);
+00144                 ifile.serialCont (container);
+00145                 ifile.close ();
+00146         }
+00147         catch (NLMISC::Exception &e)
+00148         {
+00149                 nlinfo ("loadForm(): Exception during reading the packed file, I'll reconstruct it (%s)", e.what());
+00150                 // clear the container because it can contains partially loaded sheet so we must clean it before continue
+00151                 container.clear ();
+00152         }
+00153         NLMISC::CIFile::setVersionException(olde, newe);
+00154 
+00155         // if we don't want to update packed sheet, we nothing more to do
+00156         if (!updatePackedSheet)
+00157         {
+00158                 nlinfo ("Don't update the packed sheet with real sheet");
+00159                 return;
+00160         }
+00161 
+00162         // build a vector of the sheetFilters sheet ids (ie: "item")
+00163         std::vector<NLMISC::CSheetId> sheetIds;
+00164         std::vector<std::string> filenames;
+00165         for (uint i = 0; i < sheetFilters.size(); i++)
+00166                 NLMISC::CSheetId::buildIdVector(sheetIds, filenames, sheetFilters[i]);
+00167 
+00168         // if there s no file, nothing to do
+00169         if (sheetIds.empty())
+00170                 return;
+00171 
+00172         // set up the current sheet in container to remove sheet that are in the container and not in the directory anymore
+00173         std::map<NLMISC::CSheetId, bool> sheetToRemove;
+00174         for (typename std::map<NLMISC::CSheetId, T>::iterator it = container.begin(); it != container.end(); it++)
+00175         {
+00176                 sheetToRemove.insert (make_pair((*it).first, true));
+00177         }
+00178 
+00179         // check if we need to create a new .pitems or just read it
+00180         uint32 packedFiledate = NLMISC::CFile::getFileModificationDate(packedFilenamePath);
+00181 
+00182         bool containerChanged = false;
+00183 
+00184         NLGEORGES::UFormLoader *formLoader = NULL;
+00185 
+00186         std::vector<uint> NeededToRecompute;
+00187 
+00188         for (uint k = 0; k < filenames.size(); k++)
+00189         {
+00190                 std::string p = NLMISC::CPath::lookup (filenames[k], false, false);
+00191                 if (p.empty()) continue;
+00192                 uint32 d = NLMISC::CFile::getFileModificationDate(p);
+00193 
+00194                 // no need to remove this sheet
+00195                 sheetToRemove[sheetIds[k]] = false;
+00196 
+00197                 if( d > packedFiledate || container.find (sheetIds[k]) == container.end())
+00198                 {
+00199                         NeededToRecompute.push_back(k);
+00200                 }
+00201         }
+00202 
+00203         nlinfo ("%d sheets checked, %d need to be recomputed", filenames.size(), NeededToRecompute.size());
+00204 
+00205         NLMISC::TTime last = NLMISC::CTime::getLocalTime ();
+00206         NLMISC::TTime start = NLMISC::CTime::getLocalTime ();
+00207 
+00208         NLMISC::CSmartPtr<NLGEORGES::UForm> form;
+00209 
+00210         for (uint j = 0; j < NeededToRecompute.size(); j++)
+00211         {
+00212                 if(NLMISC::CTime::getLocalTime () > last + 5000)
+00213                 {
+00214                         last = NLMISC::CTime::getLocalTime ();
+00215                         if(j>0)
+00216                                 nlinfo ("%.0f%% completed (%d/%d), %d seconds remaining", (float)j*100.0/NeededToRecompute.size(),j,NeededToRecompute.size(), (NeededToRecompute.size()-j)*(last-start)/j/1000);
+00217                 }
+00218 
+00219                 // create the georges loader if necessary
+00220                 if (formLoader == NULL)
+00221                 {
+00222                         WarningLog->addNegativeFilter("CFormLoader: Can't open the form file");
+00223                         formLoader = NLGEORGES::UFormLoader::createLoader ();
+00224                 }
+00225 
+00226                 // Load the form with given sheet id
+00227                 form = formLoader->loadForm (sheetIds[NeededToRecompute[j]].toString().c_str ());
+00228                 if (form)
+00229                 {
+00230 /*                      if (packedFiledate > 0)
+00231                         {
+00232                                 if (d > packedFiledate)
+00233                                         nlinfo ("loadForm(): the sheet '%s' is newer than the packed one, I reload it", p.c_str());
+00234                                 else
+00235                                         nlinfo ("loadForm(): the sheet '%s' is not in the packed sheets, I load it", p.c_str());
+00236                         }*/
+00237                         
+00238                         // add the new creature, it could be already loaded by the packed sheets but will be overwrite with the new one
+00239                         typedef typename std::map<NLMISC::CSheetId, T>::iterator TType1;
+00240             typedef typename std::pair<TType1, bool> TType2;
+00241                         TType2 res = container.insert(std::make_pair(sheetIds[NeededToRecompute[j]],T()));
+00242 
+00243                         (*res.first).second.readGeorges (form, sheetIds[NeededToRecompute[j]]);
+00244                         containerChanged = true;
+00245                 }
+00246         }
+00247 
+00248         nlinfo ("%d seconds to recompute %d sheets", (uint32)(NLMISC::CTime::getLocalTime()-start)/1000, NeededToRecompute.size());
+00249 
+00250         // free the georges loader if necessary
+00251         if (formLoader != NULL)
+00252         {
+00253                 NLGEORGES::UFormLoader::releaseLoader (formLoader);
+00254                 WarningLog->removeFilter ("CFormLoader: Can't open the form file");
+00255         }
+00256 
+00257         // we have now to remove sheet that are in the container and not exist anymore in the sheet directories
+00258         for (std::map<NLMISC::CSheetId, bool>::iterator it2 = sheetToRemove.begin(); it2 != sheetToRemove.end(); it2++)
+00259         {
+00260                 if((*it2).second)
+00261                 {
+00262                         nlinfo ("the sheet '%s' is not in the directory, remove it from container", (*it2).first.toString().c_str());
+00263                         container.erase((*it2).first);
+00264                         containerChanged = true;
+00265                 }
+00266         }
+00267 
+00268         // now, save the new container in the packedfile
+00269         try
+00270         {
+00271                 if(containerChanged)
+00272                 {
+00273                         NLMISC::COFile ofile;
+00274                         ofile.open(packedFilenamePath);
+00275                         uint ver = T::getVersion ();
+00276                         uint32 nbEntries = sheetIds.size();
+00277                         ofile.serial (nbEntries);
+00278                         ofile.serialVersion(ver);
+00279                         ofile.serialCont(container);
+00280                         ofile.close ();
+00281                 }
+00282         }
+00283         catch (NLMISC::Exception &e)
+00284         {
+00285                 nlinfo ("loadForm(): Exception during saving the packed file, it will be recreated next launch (%s)", e.what());
+00286         }
+00287 
+00288         // housekeeping
+00289         sheetIds.clear ();
+00290         filenames.clear ();
+00291 }
+00292 
+00293 
+00299 template <class T>
+00300 void loadForm (const std::string &sheetFilter, const std::string &packedFilename, std::map<std::string, T> &container, bool updatePackedSheet=true)
+00301 {
+00302         std::vector<std::string> vs;
+00303         vs.push_back(sheetFilter);
+00304         loadForm(vs, packedFilename, container, updatePackedSheet);
+00305 }
+00306 
+00307 
+00313 template <class T>
+00314 void loadForm (const std::vector<std::string> &sheetFilters, const std::string &packedFilename, std::map<std::string, T> &container, bool updatePackedSheet=true)
+00315 {
+00316         // check the extension (i know that file like "foo.packed_sheetsbar" will be accepted but this check is enough...)
+00317         nlassert (packedFilename.find (".packed_sheets") != std::string::npos);
+00318 
+00319         std::string packedFilenamePath = NLMISC::CPath::lookup(packedFilename, false);
+00320         if (packedFilenamePath.empty())
+00321         {
+00322                 packedFilenamePath = packedFilename;
+00323         }
+00324 
+00325         // make sure the CSheetId singleton has been properly initialised
+00326 //      NLMISC::CSheetId::init(updatePackedSheet);
+00327 
+00328         bool olde, newe;
+00329         NLMISC::CIFile::getVersionException(olde, newe);
+00330         // load the packed sheet if exists
+00331         try
+00332         {
+00333                 NLMISC::CIFile ifile;
+00334                 ifile.setCacheFileOnOpen(true);
+00335                 ifile.open (packedFilenamePath);
+00336                 // an exception will be launch if the file is not the good version or if the file is not found
+00337 
+00338                 nlinfo ("loadForm(): Loading packed file '%s'", packedFilename.c_str());
+00339                 
+00340                 uint32 nbEntries;
+00341                 ifile.serial (nbEntries);
+00342                 ifile.setVersionException (true, true);
+00343                 uint ver = T::getVersion ();
+00344                 ifile.serialVersion(ver);
+00345                 ifile.serialCont (container);
+00346                 ifile.close ();
+00347         }
+00348         catch (NLMISC::Exception &e)
+00349         {
+00350                 nlinfo ("loadForm(): Exception during reading the packed file, I'll reconstruct it (%s)", e.what());
+00351                 // clear the container because it can contains partially loaded sheet so we must clean it before continue
+00352                 container.clear ();
+00353         }
+00354         NLMISC::CIFile::setVersionException(olde, newe);
+00355 
+00356         // if we don't want to update packed sheet, we nothing more to do
+00357         if (!updatePackedSheet)
+00358         {
+00359                 nlinfo ("Don't update the packed sheet with real sheet");
+00360                 return;
+00361         }
+00362 
+00363         // build a vector of the sheetFilters sheet ids (ie: "item")
+00364 //      std::vector<std::string> sheetNames;
+00365         std::vector<std::string> sheetNames;
+00366 //      for (uint i = 0; i < sheetFilters.size(); i++)
+00367 //              NLMISC::CSheetId::buildIdVector(sheetIds, filenames, sheetFilters[i]);
+00368         {
+00369                 std::vector<std::string>::const_iterator first(sheetFilters.begin()), last(sheetFilters.end());
+00370                 for (; first != last; ++first)
+00371                         NLMISC::CPath::getFileList(*first, sheetNames);
+00372 
+00373         }
+00374 
+00375         // if there s no file, nothing to do
+00376         if (sheetNames.empty())
+00377                 return;
+00378 
+00379         // set up the current sheet in container to remove sheet that are in the container and not in the directory anymore
+00380         std::map<std::string, bool> sheetToRemove;
+00381         for (typename std::map<std::string, T>::iterator it = container.begin(); it != container.end(); ++it)
+00382         {
+00383                 sheetToRemove.insert (make_pair((*it).first, true));
+00384         }
+00385 
+00386         // check if we need to create a new .pitems or just read it
+00387         uint32 packedFiledate = NLMISC::CFile::getFileModificationDate(packedFilenamePath);
+00388 
+00389         bool containerChanged = false;
+00390 
+00391         NLGEORGES::UFormLoader *formLoader = NULL;
+00392 
+00393         std::vector<uint> NeededToRecompute;
+00394 
+00395         for (uint k = 0; k < sheetNames.size(); k++)
+00396         {
+00397                 std::string p = NLMISC::CPath::lookup (sheetNames[k], false, false);
+00398                 if (p.empty()) continue;
+00399                 uint32 d = NLMISC::CFile::getFileModificationDate(p);
+00400 
+00401                 // no need to remove this sheet
+00402                 sheetToRemove[sheetNames[k]] = false;
+00403 
+00404                 if( d > packedFiledate || container.find (sheetNames[k]) == container.end())
+00405                 {
+00406                         NeededToRecompute.push_back(k);
+00407                 }
+00408         }
+00409 
+00410         nlinfo ("%d sheets checked, %d need to be recomputed", sheetNames.size(), NeededToRecompute.size());
+00411 
+00412         NLMISC::TTime lastTime = NLMISC::CTime::getLocalTime ();
+00413         NLMISC::TTime start = NLMISC::CTime::getLocalTime ();
+00414 
+00415         NLMISC::CSmartPtr<NLGEORGES::UForm> form;
+00416 
+00417         for (uint j = 0; j < NeededToRecompute.size(); j++)
+00418         {
+00419                 if(NLMISC::CTime::getLocalTime () > lastTime + 5000)
+00420                 {
+00421                         lastTime = NLMISC::CTime::getLocalTime ();
+00422                         if(j>0)
+00423                                 nlinfo ("%.0f%% completed (%d/%d), %d seconds remaining", (float)j*100.0/NeededToRecompute.size(),j,NeededToRecompute.size(), (NeededToRecompute.size()-j)*(lastTime-start)/j/1000);
+00424                 }
+00425 
+00426                 // create the georges loader if necessary
+00427                 if (formLoader == NULL)
+00428                 {
+00429                         WarningLog->addNegativeFilter("CFormLoader: Can't open the form file");
+00430                         formLoader = NLGEORGES::UFormLoader::createLoader ();
+00431                 }
+00432 
+00433                 // Load the form with given sheet id
+00434                 form = formLoader->loadForm (sheetNames[NeededToRecompute[j]].c_str ());
+00435                 if (form)
+00436                 {
+00437 /*                      if (packedFiledate > 0)
+00438                         {
+00439                                 if (d > packedFiledate)
+00440                                         nlinfo ("loadForm(): the sheet '%s' is newer than the packed one, I reload it", p.c_str());
+00441                                 else
+00442                                         nlinfo ("loadForm(): the sheet '%s' is not in the packed sheets, I load it", p.c_str());
+00443                         }*/
+00444                         
+00445                         // add the new creature, it could be already loaded by the packed sheets but will be overwrite with the new one
+00446                         typedef typename std::map<std::string, T>::iterator TType1;
+00447             typedef typename std::pair<TType1, bool> TType2;
+00448                         TType2 res = container.insert(std::make_pair(sheetNames[NeededToRecompute[j]],T()));
+00449 
+00450                         (*res.first).second.readGeorges (form, sheetNames[NeededToRecompute[j]]);
+00451                         containerChanged = true;
+00452                 }
+00453         }
+00454 
+00455         nlinfo ("%d seconds to recompute %d sheets", (uint32)(NLMISC::CTime::getLocalTime()-start)/1000, NeededToRecompute.size());
+00456 
+00457         // free the georges loader if necessary
+00458         if (formLoader != NULL)
+00459         {
+00460                 NLGEORGES::UFormLoader::releaseLoader (formLoader);
+00461                 WarningLog->removeFilter ("CFormLoader: Can't open the form file");
+00462         }
+00463 
+00464         // we have now to remove sheet that are in the container and not exist anymore in the sheet directories
+00465         for (std::map<std::string, bool>::iterator it2 = sheetToRemove.begin(); it2 != sheetToRemove.end(); it2++)
+00466         {
+00467                 if((*it2).second)
+00468                 {
+00469                         nlinfo ("the sheet '%s' is not in the directory, remove it from container", (*it2).first.c_str());
+00470                         // informe the contained object that it is no more needed.
+00471                         container.find((*it2).first)->second.removed();
+00472                         container.erase((*it2).first);
+00473                         containerChanged = true;
+00474                 }
+00475         }
+00476 
+00477         // now, save the new container in the packedfile
+00478         try
+00479         {
+00480                 if(containerChanged)
+00481                 {
+00482                         NLMISC::COFile ofile;
+00483                         ofile.open(packedFilenamePath);
+00484                         uint ver = T::getVersion ();
+00485                         uint32 nbEntries = sheetNames.size();
+00486                         ofile.serial (nbEntries);
+00487                         ofile.serialVersion(ver);
+00488                         ofile.serialCont(container);
+00489                         ofile.close ();
+00490                 }
+00491         }
+00492         catch (NLMISC::Exception &e)
+00493         {
+00494                 nlinfo ("loadForm(): Exception during saving the packed file, it will be recreated next launch (%s)", e.what());
+00495         }
+00496 
+00497         // housekeeping
+00498 //      sheetIds.clear ();
+00499         sheetNames.clear ();
+00500 }
+00501 #endif // NL_LOAD_FORM_H
+00502 
+00503 /* End of load_form.h */
+