nevrax.org : docs

00001 
00007 /* Copyright, 2000 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 #include "../stdmisc.h"
00027 
00028 #include <time.h>
00029 #include <sys/types.h>
00030 #include <sys/stat.h>
00031 
00032 #include "nel/misc/file.h"
00033 #include "nel/misc/debug.h"
00034 #include "nel/misc/config_file.h"
00035 #include "nel/misc/path.h"
00036 
00037 using namespace std;
00038 using namespace NLMISC;
00039 
00040 extern void cfrestart (FILE *); // used to reinit the file
00041 extern int cfparse (void *);    // used to parse the file
00042 //extern FILE *cfin;
00043 extern int cf_CurrentLine;
00044 extern bool cf_OverwriteExistingVariable;
00045 extern CIFile cf_ifile;
00046 
00047 // put true if you want that the config file class check type when you call asFunctions
00048 // (for example, check when you call asInt() that the variable is an int).
00049 // when it's false, the function will convert to the wanted type (if he can)
00050 const bool CheckType = false;
00051 
00052 namespace NLMISC
00053 {
00054 
00055 char *CConfigFile::CVar::TypeName[] = { "Integer", "String", "Float" };
00056 
00057 int CConfigFile::CVar::asInt (int index) const
00058 {
00059         if (CheckType && Type != T_INT) throw EBadType (Name, Type, T_INT);
00060         switch (Type)
00061         {
00062         case T_STRING:
00063                 if (index >= (int)StrValues.size () || index < 0) throw EBadSize (Name, StrValues.size (), index);
00064                 return atoi(StrValues[index].c_str());
00065         case T_REAL:
00066                 if (index >= (int)RealValues.size () || index < 0) throw EBadSize (Name, RealValues.size (), index);
00067                 return (int)RealValues[index];
00068         default:
00069                 if (index >= (int)IntValues.size () || index < 0) throw EBadSize (Name, IntValues.size (), index);
00070                 return IntValues[index];
00071         }
00072 }
00073 
00074 double CConfigFile::CVar::asDouble (int index) const
00075 {
00076         if (CheckType && Type != T_REAL) throw EBadType (Name, Type, T_REAL);
00077         switch (Type)
00078         {
00079         case T_INT:
00080                 if (index >= (int)IntValues.size () || index < 0) throw EBadSize (Name, IntValues.size (), index);
00081                 return (double)IntValues[index];
00082         case T_STRING:
00083                 if (index >= (int)StrValues.size () || index < 0) throw EBadSize (Name, StrValues.size (), index);
00084                 return atof(StrValues[index].c_str());
00085         default:
00086                 if (index >= (int)RealValues.size () || index < 0) throw EBadSize (Name, RealValues.size (), index);
00087                 return RealValues[index];
00088         }
00089 }
00090 
00091 float CConfigFile::CVar::asFloat (int index) const
00092 {
00093         return (float) asDouble (index);
00094 }
00095 
00096 const std::string &CConfigFile::CVar::asString (int index) const
00097 {
00098         if (Type != T_STRING) throw EBadType (Name, Type, T_STRING);
00099         if (index >= (int)StrValues.size () || index < 0) throw EBadSize (Name, StrValues.size (), index);
00100         return StrValues[index];
00101 }
00102 
00103 
00104 
00105 void CConfigFile::CVar::setAsInt (int val, int index)
00106 {
00107         if (Type != T_INT) throw EBadType (Name, Type, T_INT);
00108         else if (index > (int)IntValues.size () || index < 0) throw EBadSize (Name, IntValues.size (), index);
00109         else if (index == (int)IntValues.size ()) IntValues.push_back(val);
00110         else IntValues[index] = val;
00111 }
00112 
00113 void CConfigFile::CVar::setAsDouble (double val, int index)
00114 {
00115         if (Type != T_REAL) throw EBadType (Name, Type, T_REAL);
00116         else if (index > (int)RealValues.size () || index < 0) throw EBadSize (Name, RealValues.size (), index);
00117         else if (index == (int)RealValues.size ()) RealValues.push_back(val);
00118         else RealValues[index] = val;
00119 }
00120 
00121 void CConfigFile::CVar::setAsFloat (float val, int index)
00122 {
00123         setAsDouble (val, index);
00124 }
00125 
00126 void CConfigFile::CVar::setAsString (std::string val, int index)
00127 {
00128         if (Type != T_STRING) throw EBadType (Name, Type, T_STRING);
00129         else if (index > (int)StrValues.size () || index < 0) throw EBadSize (Name, StrValues.size (), index);
00130         else if (index == (int)StrValues.size ()) StrValues.push_back(val);
00131         else StrValues[index] = val;
00132 }
00133 
00134 void CConfigFile::CVar::setAsInt (std::vector<int> vals)
00135 {
00136         if (Type != T_INT) throw EBadType (Name, Type, T_INT);
00137         else IntValues = vals;
00138 }
00139 
00140 void CConfigFile::CVar::setAsDouble (std::vector<double> vals)
00141 {
00142         if (Type != T_REAL) throw EBadType (Name, Type, T_REAL);
00143         else RealValues = vals;
00144 }
00145 
00146 void CConfigFile::CVar::setAsFloat (std::vector<float> vals)
00147 {
00148         if (Type != T_REAL) throw EBadType (Name, Type, T_REAL);
00149         else
00150         {
00151                 RealValues.clear ();
00152                 RealValues.resize (vals.size ());
00153                 for (uint i = 0; i < vals.size (); i++)
00154                         RealValues[i] = (double)vals[i];
00155         }
00156 }
00157 
00158 void CConfigFile::CVar::setAsString (std::vector<std::string> vals)
00159 {
00160         if (Type != T_STRING) throw EBadType (Name, Type, T_STRING);
00161         else StrValues = vals;
00162 }
00163 
00164 bool CConfigFile::CVar::operator==      (const CVar& var) const
00165 {
00166         if (Type == var.Type)
00167         {
00168                 switch (Type)
00169                 {
00170                 case T_INT: return IntValues == var.IntValues; break;
00171                 case T_REAL: return RealValues == var.RealValues; break;
00172                 case T_STRING: return StrValues == var.StrValues; break;
00173                 default: break;
00174                 }
00175         }
00176         return false;
00177 }
00178 
00179 bool CConfigFile::CVar::operator!=      (const CVar& var) const
00180 {
00181         return !(*this==var);
00182 }
00183 
00184 void CConfigFile::CVar::add (const CVar &var)
00185 {
00186         if (Type == var.Type)
00187         {
00188                 switch (Type)
00189                 {
00190                 case T_INT: IntValues.insert (IntValues.end(), var.IntValues.begin(), var.IntValues.end()); break;
00191                 case T_REAL: RealValues.insert (RealValues.end(), var.RealValues.begin(), var.RealValues.end()); break;
00192                 case T_STRING: StrValues.insert (StrValues.end(), var.StrValues.begin(), var.StrValues.end()); break;
00193                 default: break;
00194                 }
00195         }
00196 }
00197 
00198 int CConfigFile::CVar::size () const
00199 {
00200         switch (Type)
00201         {
00202         case T_INT: return IntValues.size ();
00203         case T_REAL: return RealValues.size ();
00204         case T_STRING: return StrValues.size ();
00205         default: return 0;
00206         }
00207 }
00208 
00209 CConfigFile::~CConfigFile ()
00210 {
00211         if (_ConfigFiles == NULL || (*_ConfigFiles).empty ()) return;
00212 
00213         vector<CConfigFile *>::iterator it = find ((*_ConfigFiles).begin (), (*_ConfigFiles).end (), this);
00214         if (it != (*_ConfigFiles).end ())
00215         {
00216                 (*_ConfigFiles).erase (it);
00217         }
00218 
00219         if ((*_ConfigFiles).empty())
00220         {
00221                 delete _ConfigFiles;
00222                 _ConfigFiles = NULL;
00223         }
00224 }
00225 
00226 void CConfigFile::load (const string &fileName)
00227 {
00228         if(fileName.empty())
00229         {
00230                 nlwarning ("Can't load a empty file name configfile");
00231                 return;
00232         }
00233 
00234         _FileName = fileName;
00235 
00236         if (_ConfigFiles == NULL)
00237         {
00238                 _ConfigFiles = new std::vector<CConfigFile *>;
00239         }
00240         (*CConfigFile::_ConfigFiles).push_back (this);
00241         reparse ();
00242 
00243         // If we find a linked config file, load it but don't overload already existant variable
00244         CVar *var = getVarPtr ("RootConfigFilename");
00245         if (var)
00246         {
00247                 string RootConfigFilename = var->asString();
00248                 nlinfo ("RootConfigFilename variable found in the '%s' config file, parse it (%s)", fileName.c_str(), RootConfigFilename.c_str());
00249 
00250                 string path = CFile::getPath(fileName);
00251 
00252                 if (!path.empty())
00253                         path +=  "/";
00254 
00255                 path += RootConfigFilename;
00256 
00257                 reparse (path.c_str());
00258         }
00259 
00260 //      print ();
00261 }
00262 
00263 
00264 bool CConfigFile::loaded()
00265 {
00266         return !CConfigFile::_FileName.empty();
00267 }
00268 
00269 
00270 void CConfigFile::reparse (const char *filename, bool callingCallback)
00271 {
00272         if (filename == NULL)
00273         {
00274                 _LastModified = getLastModified ();
00275 
00276                 nlassert (!_FileName.empty());
00277 
00278                 if (cf_ifile.open (_FileName))
00279                 {
00280                         // if we clear all the array, we'll lost the callback on variable and all information
00281                         //              _Vars.clear();
00282                         cfrestart (NULL);
00283                         cf_OverwriteExistingVariable = true;
00284                         bool parsingOK = (cfparse (&(_Vars)) == 0);
00285                         cf_ifile.close();
00286                         if (!parsingOK)
00287                         {
00288                                 nlwarning ("Parsing error in file %s line %d", _FileName.c_str(), cf_CurrentLine);
00289                                 throw EParseError (_FileName, cf_CurrentLine);
00290                         }
00291                 }
00292                 else
00293                 {
00294                         nlwarning ("ConfigFile '%s' not found in the path '%s'", _FileName.c_str(), CPath::getCurrentPath().c_str());
00295                         throw EFileNotFound (_FileName);
00296                 }
00297 
00298                 /*
00299                 cfin = fopen (_FileName.c_str (), "r");
00300                 if (cfin != NULL)
00301                 {
00302         // if we clear all the array, we'll lost the callback on variable and all information
00303         //              _Vars.clear();
00304                         cfrestart (cfin);
00305                         cf_OverwriteExistingVariable = true;
00306                         bool parsingOK = (cfparse (&(_Vars)) == 0);
00307                         fclose (cfin);
00308                         if (!parsingOK) throw EParseError (_FileName, cf_CurrentLine);
00309                 }
00310                 else
00311                 {
00312                         nlwarning ("ConfigFile '%s' not found in the path '%s'", _FileName.c_str(), CPath::getCurrentPath().c_str());
00313                         throw EFileNotFound (_FileName);
00314                 }
00315                 */
00316         }
00317         else
00318         {
00319                 nlassert (strlen(filename)>0);
00320 
00321                 // load external config filename, don't overwrite existant variable
00322                 if (cf_ifile.open (filename))
00323                 {
00324                         cfrestart (NULL);
00325                         cf_OverwriteExistingVariable = false;
00326                         bool parsingOK = (cfparse (&(_Vars)) == 0);
00327                         cf_ifile.close ();
00328                         if (!parsingOK)
00329                         {
00330                                 nlwarning ("Parsing error in file %s line %d", filename, cf_CurrentLine);
00331                                 throw EParseError (filename, cf_CurrentLine);
00332                         }
00333                 }
00334                 else
00335                 {
00336                         nlwarning ("RootConfigFilename '%s' not found", _FileName.c_str());
00337                 }
00338 
00339 /*              cfin = fopen (filename, "r");
00340                 if (cfin != NULL)
00341                 {
00342                         cfrestart (cfin);
00343                         cf_OverwriteExistingVariable = false;
00344                         bool parsingOK = (cfparse (&(_Vars)) == 0);
00345                         fclose (cfin);
00346                         if (!parsingOK) throw EParseError (_FileName, cf_CurrentLine);
00347                 }
00348                 else
00349                 {
00350                         nlwarning ("RootConfigFilename '%s' not found", _FileName.c_str());
00351                 }
00352 */      }
00353 
00354         if (callingCallback)
00355         {
00356                 nlwarning("Callback ptr : %p", _Callback);
00357                 if (_Callback != NULL) 
00358                         _Callback();
00359         }
00360 }
00361 
00362 
00363 
00364 CConfigFile::CVar &CConfigFile::getVar (const std::string &varName)
00365 {
00366         uint i;
00367         for (i = 0; i < _Vars.size(); i++)
00368         {
00369                 // the type could be T_UNKNOWN if we add a callback on this name but this var is not in the config file
00370                 if (_Vars[i].Name == varName && (_Vars[i].Type != CVar::T_UNKNOWN || _Vars[i].Comp))
00371                 {
00372                         return _Vars[i];
00373                         break;
00374                 }
00375         }
00376 
00377         // if not found, add it in the array if necessary
00378         for (i = 0; i < UnknownVariables.size(); i++)
00379                 if(UnknownVariables[i] == varName)
00380                         break;
00381         if (i == UnknownVariables.size())
00382                 UnknownVariables.push_back(varName);
00383 
00384         throw EUnknownVar (_FileName, varName);
00385 }
00386 
00387 
00388 CConfigFile::CVar *CConfigFile::getVarPtr (const std::string &varName)
00389 {
00390         uint i;
00391         for (i = 0; i < _Vars.size(); i++)
00392         {
00393                 // the type could be T_UNKNOWN if we add a callback on this name but this var is not in the config file
00394                 if (_Vars[i].Name == varName && (_Vars[i].Type != CVar::T_UNKNOWN || _Vars[i].Comp))
00395                 {
00396                         return &(_Vars[i]);
00397                 }
00398         }
00399 
00400         // if not found, add it in the array if necessary
00401         for (i = 0; i < UnknownVariables.size(); i++)
00402                 if(UnknownVariables[i] == varName)
00403                         break;
00404         if (i == UnknownVariables.size())
00405                 UnknownVariables.push_back(varName);
00406 
00407         return NULL;
00408 }
00409 
00410 bool CConfigFile::exists (const std::string &varName)
00411 {
00412         for (uint i = 0; i < _Vars.size(); i++)
00413         {
00414                 // the type could be T_UNKNOWN if we add a callback on this name but this var is not in the config file
00415                 if (_Vars[i].Name == varName && (_Vars[i].Type != CVar::T_UNKNOWN || _Vars[i].Comp))
00416                 {
00417                         return true;
00418                 }
00419         }
00420         return false;
00421 }
00422 
00423 void CConfigFile::save () const
00424 {
00425         FILE *fp = fopen (_FileName.c_str (), "w");
00426         if (fp == NULL)
00427         {
00428                 nlwarning ("Couldn't create %s file", _FileName.c_str ());
00429                 return;
00430         }
00431 
00432         for(int i = 0; i < (int)_Vars.size(); i++)
00433         {
00434                 if (_Vars[i].Comp)
00435                 {
00436                         fprintf(fp, "%-20s = { ", _Vars[i].Name.c_str());
00437                         switch (_Vars[i].Type)
00438                         {
00439                         case CConfigFile::CVar::T_INT:
00440                         {
00441                                 for (int it=0; it < (int)_Vars[i].IntValues.size(); it++)
00442                                 {
00443                                         fprintf(fp, "%d%s", _Vars[i].IntValues[it], it<(int)_Vars[i].IntValues.size()-1?", ":" ");
00444                                 }
00445                                 break;
00446                         }
00447                         case CConfigFile::CVar::T_STRING:
00448                         {
00449                                 for (int st=0; st < (int)_Vars[i].StrValues.size(); st++)
00450                                 {
00451                                         fprintf(fp, "\"%s\"%s", _Vars[i].StrValues[st].c_str(), st<(int)_Vars[i].StrValues.size()-1?", ":" ");
00452                                 }
00453                                 break;
00454                         }
00455                         case CConfigFile::CVar::T_REAL:
00456                         {
00457                                 for (int rt=0; rt < (int)_Vars[i].RealValues.size(); rt++)
00458                                 {
00459                                         fprintf(fp, "%.10f%s", _Vars[i].RealValues[rt], rt<(int)_Vars[i].RealValues.size()-1?", ":" ");
00460                                 }
00461                                 break;
00462                         }
00463                         default: break;
00464                         }
00465                         fprintf(fp, "};\n");
00466                 }
00467                 else
00468                 {
00469                         switch (_Vars[i].Type)
00470                         {
00471                         case CConfigFile::CVar::T_INT:
00472                                 fprintf(fp, "%-20s = %d;\n", _Vars[i].Name.c_str(), _Vars[i].IntValues[0]);
00473                                 break;
00474                         case CConfigFile::CVar::T_STRING:
00475                                 fprintf(fp, "%-20s = \"%s\";\n", _Vars[i].Name.c_str(), _Vars[i].StrValues[0].c_str());
00476                                 break;
00477                         case CConfigFile::CVar::T_REAL:
00478                                 fprintf(fp, "%-20s = %.10f;\n", _Vars[i].Name.c_str(), _Vars[i].RealValues[0]);
00479                                 break;
00480                         default: break;
00481                         }
00482                 }
00483         }
00484         fclose (fp);
00485 }
00486 
00487 void CConfigFile::print () const
00488 {
00489         print(InfoLog);
00490 }
00491 
00492 void CConfigFile::print (CLog *log) const
00493 {
00494         createDebug ();
00495 
00496         log->displayRawNL ("ConfigFile %s have %d variables:", _FileName.c_str(), _Vars.size());
00497         log->displayRawNL ("------------------------------------------------------");
00498         for(int i = 0; i < (int)_Vars.size(); i++)
00499         {
00500                 log->displayRaw ((_Vars[i].Callback==NULL)?"   ":"CB ");
00501                 if (_Vars[i].Comp)
00502                 {
00503                         switch (_Vars[i].Type)
00504                         {
00505                         case CConfigFile::CVar::T_INT:
00506                         {
00507                                 log->displayRaw ("%-20s { ", _Vars[i].Name.c_str());
00508                                 for (int it=0; it < (int)_Vars[i].IntValues.size(); it++)
00509                                 {
00510                                         log->displayRaw ("'%d' ", _Vars[i].IntValues[it]);
00511                                 }
00512                                 log->displayRawNL ("}");
00513                                 break;
00514                         }
00515                         case CConfigFile::CVar::T_STRING:
00516                         {
00517                                 log->displayRaw ("%-20s { ", _Vars[i].Name.c_str());
00518                                 for (int st=0; st < (int)_Vars[i].StrValues.size(); st++)
00519                                 {
00520                                         log->displayRaw ("\"%s\" ", _Vars[i].StrValues[st].c_str());
00521                                 }
00522                                 log->displayRawNL ("}");
00523                                 break;
00524                         }
00525                         case CConfigFile::CVar::T_REAL:
00526                         {
00527                                 log->displayRaw ("%-20s { " , _Vars[i].Name.c_str());
00528                                 for (int rt=0; rt < (int)_Vars[i].RealValues.size(); rt++)
00529                                 {
00530                                         log->displayRaw ("`%f` ", _Vars[i].RealValues[rt]);
00531                                 }
00532                                 log->displayRawNL ("}");
00533                                 break;
00534                         }
00535                         case CConfigFile::CVar::T_UNKNOWN:
00536                         {
00537                                  log->displayRawNL ("%-20s { }" , _Vars[i].Name.c_str());
00538                                 break;
00539                         }
00540                         default:
00541                         {
00542                                 log->displayRawNL ("%-20s <default case>" , _Vars[i].Name.c_str());
00543                                 break;
00544                         }
00545                         }
00546                 }
00547                 else
00548                 {
00549                         switch (_Vars[i].Type)
00550                         {
00551                         case CConfigFile::CVar::T_INT:
00552                                 log->displayRawNL ("%-20s '%d'", _Vars[i].Name.c_str(), _Vars[i].IntValues[0]);
00553                                 break;
00554                         case CConfigFile::CVar::T_STRING:
00555                                 log->displayRawNL ("%-20s \"%s\"", _Vars[i].Name.c_str(), _Vars[i].StrValues[0].c_str());
00556                                 break;
00557                         case CConfigFile::CVar::T_REAL:
00558                                 log->displayRawNL ("%-20s `%f`", _Vars[i].Name.c_str(), _Vars[i].RealValues[0]);
00559                                 break;
00560                         default:
00561                         {
00562                                 log->displayRawNL ("%-20s <default case>" , _Vars[i].Name.c_str());
00563                                 break;
00564                         }
00565                         }
00566                 }
00567         }
00568 }
00569 
00570 void CConfigFile::setCallback (void (*cb)())
00571 {
00572         _Callback = cb;
00573 }
00574 
00575 void CConfigFile::setCallback (const string &VarName, void (*cb)(CConfigFile::CVar &var))
00576 {
00577         for (vector<CVar>::iterator it = _Vars.begin (); it != _Vars.end (); it++)
00578         {
00579                 if (VarName == (*it).Name)
00580                 {
00581                         (*it).Callback = cb;
00582                         return;
00583                 }
00584         }
00585         // VarName doesn't exist, add it now for the futur
00586         CVar Var;
00587         Var.Name = VarName;
00588         Var.Callback = cb;
00589         Var.Type = CVar::T_UNKNOWN;
00590         _Vars.push_back (Var);
00591 }
00592 
00593 void CConfigFile::setLastModifiedNow ()
00594 {
00595         _LastModified = getLastModified ();
00596 }
00597 
00598 
00599 // ***************************************************************************
00600 
00601 
00602 vector<CConfigFile *> *CConfigFile::_ConfigFiles = NULL;
00603 
00604 uint32  CConfigFile::_Timeout = 1000;
00605 
00606 uint32 CConfigFile::getLastModified ()
00607 {
00608         uint pos;
00609         string fn;
00610         if ((pos=_FileName.find('@')) != string::npos)
00611         {
00612                 fn = _FileName.substr (0, pos);
00613         }
00614         else
00615         {
00616                 fn = _FileName;
00617         }
00618 #if defined (NL_OS_WINDOWS)
00619         struct _stat buf;
00620         int result = _stat (fn.c_str (), &buf);
00621 #elif defined (NL_OS_UNIX)
00622         struct stat buf;
00623         int result = stat (fn.c_str (), &buf);
00624 #endif
00625 
00626         if (result != 0) return 0;
00627         else return buf.st_mtime;
00628 }
00629 
00630 
00631 void CConfigFile::checkConfigFiles ()
00632 {
00633         if (_ConfigFiles == NULL) return;
00634 
00635         static time_t LastCheckTime = time (NULL);
00636         if (_Timeout > 0 && (float)(time (NULL) - LastCheckTime)*1000.0f < (float)_Timeout) return;
00637 
00638         LastCheckTime = time (NULL);
00639 
00640         for (vector<CConfigFile *>::iterator it = (*_ConfigFiles).begin (); it != (*_ConfigFiles).end (); it++)
00641         {
00642                 if ((*it)->_LastModified != (*it)->getLastModified ())
00643                 {
00644                         try
00645                         {
00646                                 (*it)->reparse ();
00647                         }
00648                         catch (EConfigFile &e)
00649                         {
00650                                 nlwarning ("Exception will rereading modified config file: %s", e.what ());
00651                         }
00652                 }
00653         }
00654 }
00655 
00656 void CConfigFile::setTimeout (uint32 timeout)
00657 {
00658         nlassert (timeout>=0);
00659         _Timeout = timeout;
00660 }
00661 
00662 } // NLMISC
config_file.cpp
