ryzom/common/src/game_share/cst_loader.h

   1 // Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
   2 // Copyright (C) 2010  Winch Gate Property Limited
   3 //
   4 // This program is free software: you can redistribute it and/or modify
   5 // it under the terms of the GNU Affero General Public License as
   6 // published by the Free Software Foundation, either version 3 of the
   7 // License, or (at your option) any later version.
   8 //
   9 // This program is distributed in the hope that it will be useful,
  10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 // GNU Affero General Public License for more details.
  13 //
  14 // You should have received a copy of the GNU Affero General Public License
  15 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16
  17
  18
  19 #ifndef CST_LOADER_H
  20 #define CST_LOADER_H
  21
  22 #include "nel/misc/types_nl.h"
  23 #include "nel/misc/debug.h"
  24
  25 #include <map>
  26 #include <vector>
  27 #include <string>
  28
  29
  30 /**
  31  * CSTLoader
  32  * \author Stephane Coutelas
  33  * \author Nevrax France
  34  * \date 2001
  35  */
  36 class CSTLoader
  37 {
  38 public:
  39
  40         /// data type
  41         enum TDataType
  42         {
  43                 UINT8,
  44                 SINT8,
  45                 UINT16,
  46                 SINT16,
  47                 UINT32,
  48                 SINT32,
  49                 FLOAT,
  50                 STRING,
  51                 BOOL
  52         };
  53
  54 private:
  55
  56         /// cst file
  57         FILE *_File;
  58
  59         /// name of the cst file (used for debug information)
  60         std::string     _FileName;
  61
  62         /// separators
  63         std::string _Seps;
  64
  65         /// current line in the file
  66         uint _LineCount;
  67
  68         /// columns label of the actually readen data file
  69         std::vector<std::string> _Columns;
  70
  71         /// file format expected
  72         std::map<std::string,TDataType> _FileFormat;
  73
  74         /// tokens for each expected columns
  75         std::map<std::string, std::string> _Tokens;
  76
  77 public:
  78
  79         /// constructor
  80         CSTLoader()
  81         {
  82                 _Seps = "\t;";
  83                 _LineCount = 0;
  84         }
  85
  86         /**
  87          * Set the separators to extract tokens
  88          * \param seps all characters than can be a separator
  89          */
  90         void setSeparators( std::string seps )
  91         {
  92                 _Seps = seps;
  93         }
  94
  95
  96         /**
  97          * (For files respecting the dynamical column label format : name<type>)
  98          * Open a file, and init the file format. Each column has a label and a data type
  99          *
 100          * \param fileName the name of the file
 101          * \param fileFormat the name of the columns and their data type
 102          */
 103         void buildTableFormat( const std::string &fileName, std::list<std::pair< std::string,TDataType> >& tableFormat );
 104
 105
 106         /**
 107          * (For files respecting the dynamical column label format : name<type>)
 108          * Read all the data of the file. For each object it fills a list of value(string)
 109          *
 110          * \param data the list of the name of the columns and their data type
 111          */
 112         void readData( std::list<std::list<std::string> >& data );
 113
 114         /**
 115          * Open a file, and init the file format
 116          * \param fileName the name of the file
 117          * \param fileFormat the name of the columns and their data type
 118          */
 119         void init( const std::string &fileName, const std::map<std::string,TDataType>& fileFormat);
 120
 121
 122         /**
 123          * read a line in the file and check validity of token data type
 124          * \return false if the ned of file has been reached, true else.
 125          */
 126         bool readLine();
 127
 128
 129         /**
 130          * return the value corresponding to the given column in the current file line
 131          * \param value  a value in the table
 132          */
 133         template<class T> void getValue( const std::string& columnLabel, T& value )
 134         {
 135                 std::map<std::string,std::string>::const_iterator itt = _Tokens.find( columnLabel );
 136                 if( itt == _Tokens.end() )
 137                 {
 138                         nlerror("The value for the column %s has not been read in the line",columnLabel.c_str());
 139                 }
 140
 141                 std::map<std::string,TDataType>::const_iterator itf = _FileFormat.find( columnLabel );
 142                 if( itf == _FileFormat.end() )
 143                 {
 144                         nlerror("The column %s is not in the file format",columnLabel.c_str());
 145                 }
 146
 147                 nlassert( (*itf).second != STRING && (*itf).second != BOOL );
 148
 149                 switch( (*itf).second )
 150                 {
 151                         case UINT8 :
 152                         case SINT8 :
 153                         case UINT16 :
 154                         case SINT16 :
 155                         case UINT32 :
 156                         case SINT32 :
 157                         case FLOAT :
 158                                 fromString((*itt).second, value);
 159                                 break;
 160                         default:
 161                                 break;
 162                 }
 163         }
 164
 165         /**
 166          * return the string value corresponding to the given column in the current file line
 167          * \param value a string value in the table
 168          */
 169         void getStringValue( const std::string& columnLabel, std::string& value )
 170         {
 171                 std::map<std::string,std::string>::const_iterator itt = _Tokens.find( columnLabel );
 172                 if( itt == _Tokens.end() )
 173                 {
 174                         nlerror("The value for the column %s has not been read in the line",columnLabel.c_str());
 175                 }
 176
 177                 std::map<std::string,TDataType>::const_iterator itf = _FileFormat.find( columnLabel );
 178                 if( itf == _FileFormat.end() )
 179                 {
 180                         nlerror("The column %s is not in the file format",columnLabel.c_str());
 181                 }
 182
 183                 nlassert( (*itf).second == STRING );
 184
 185                 value = (*itt).second;
 186         }
 187
 188         /**
 189          * return the bool value corresponding to the given column in the current file line
 190          * \param value a bool value in the table
 191          */
 192         void getBoolValue( const std::string& columnLabel, bool& value )
 193         {
 194                 std::map<std::string,std::string>::const_iterator itt = _Tokens.find( columnLabel );
 195                 if( itt == _Tokens.end() )
 196                 {
 197                         nlerror("The value for the column %s has not been read in the line",columnLabel.c_str());
 198                 }
 199
 200                 std::map<std::string,TDataType>::const_iterator itf = _FileFormat.find( columnLabel );
 201                 if( itf == _FileFormat.end() )
 202                 {
 203                         nlerror("The column %s is not in the file format",columnLabel.c_str());
 204                 }
 205
 206                 nlassert( (*itf).second == BOOL );
 207
 208                 NLMISC::fromString((*itt).second, value);
 209         }
 210
 211
 212         /// close file
 213         void close()
 214         {
 215                 fclose(_File);
 216                 _File = NULL;
 217         }
 218
 219
 220         void Load(const std::string &fileName)
 221         {
 222                 // Generates the base class
 223                 std::list< std::pair<std::string,TDataType> > format;
 224                 buildTableFormat( fileName, format );
 225                 generateBaseClass( format);
 226
 227                 // Generates a derived class for each type of object
 228                 std::list< std::list<std::string> > data;
 229                 readData( data );
 230                 generateDerivedClasses( format, data );
 231         }
 232
 233         void generateBaseClass(const std::list< std::pair<std::string,TDataType> > &/* format */)
 234         {
 235                 std::string content;
 236                 content += "From Agent : Define Item\n";
 237                 content += "{\n";
 238 /*              content += "\tComponent:\n";
 239
 240                 std::list< std::pair<std::string,TDataType> >::iterator it_obj = format.begin();
 241                 it_obj++;
 242                 while ( it_obj != format.end() )
 243                 {
 244                         content += "\t\t" + convertFromType((*it_obj).second);
 245                         content += "<'" + (*it_obj).first + "', Static>;\n";
 246                         it_obj++;
 247                 }
 248
 249                 content += "\tEnd\n"; */
 250                 content += "}\n";
 251                 content += "\n";
 252
 253                 fwrite(content.c_str(), 1, content.length(), _File);
 254         }
 255
 256         void generateDerivedClasses(const std::list< std::pair<std::string, TDataType> > &, const std::list< std::list< std::string> > &);
 257
 258         TDataType convertType(const std::string &type_str)
 259         {
 260                 if ( type_str == "UINT8")
 261                         return UINT8;
 262                 if ( type_str == "SINT8")
 263                         return SINT8;
 264                 if ( type_str == "UINT16")
 265                         return UINT16;
 266                 if ( type_str == "SINT16")
 267                         return SINT16;
 268                 if ( type_str == "UINT32")
 269                         return UINT32;
 270                 if ( type_str == "SINT32")
 271                         return SINT32;
 272                 if ( type_str == "FLOAT")
 273                         return FLOAT;
 274                 if ( type_str == "STRING")
 275                         return STRING;
 276                 if ( type_str == "BOOL")
 277                         return BOOL;
 278                 return (TDataType)0;
 279         }
 280
 281         std::string convertFromType(TDataType type);
 282
 283         std::string convertName(const std::string &name) const
 284         {
 285                 int i = 0;
 286                 char buffer[1024];
 287                 std::string::const_iterator it_c = name.begin();
 288                 while ( it_c != name.end() )
 289                 {
 290                         char c = *it_c;
 291                         switch ( c )
 292                         {
 293                                 case ' ':
 294                                 case '.':
 295                                         buffer[i] = '_';
 296                                         break;
 297
 298                                 case ',':
 299                                         buffer[i] = '.';
 300                                         break;
 301
 302                                 default:
 303                                         buffer[i] = *it_c;
 304                         }
 305                         i++;
 306                         it_c++;
 307                 }
 308                 buffer[i] = 0;
 309                 return std::string( buffer );
 310         }
 311 };
 312
 313 #endif // CST_LOADER_H