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_STRING_ID_ARRAY_H
+00027 #define NL_STRING_ID_ARRAY_H
+00028 
+00029 #include "nel/misc/types_nl.h"
+00030 
+00031 #include <math.h>
+00032 #include <string>
+00033 #include <vector>
+00034 #include <set>
+00035 #include <algorithm>
+00036 
+00037 #include "nel/misc/debug.h"
+00038 
+00039 
+00040 namespace NLMISC {
+00041 
+00042 
+00050 class CStringIdArray
+00051 {
+00052 public:
+00053 
+00054         typedef sint16 TStringId;
+00055 
+00056         CStringIdArray () : _IgnoreAllUnknownId(false) { }
+00057 
+00059         void addString(const std::string &str, TStringId id)
+00060         {
+00061                 nlassert (id >= 0 && id < pow(2, sizeof (TStringId)*8));
+00062                 nlassert (!str.empty());
+00063 
+00064                 if (id >= (sint32) _StringArray.size())
+00065                         _StringArray.resize(id+1);
+00066 
+00067                 _StringArray[id] = str;
+00068 
+00069                 if (!_IgnoreAllUnknownId)
+00070                 {
+00071                         _AskedStringArray.erase (str);
+00072                         _NeedToAskStringArray.erase (str);
+00073                 }
+00074         }
+00075 
+00077         void addString(const std::string &str)
+00078         {
+00079                 nlassert (_StringArray.size () < pow(2, sizeof (TStringId)*8));
+00080                 nlassert (!str.empty());
+00081 
+00082                 // add at the end
+00083                 addString (str, _StringArray.size ());
+00084         }
+00085 
+00089         TStringId getId (const std::string &str, bool IgnoreIfUnknown = false)
+00090         {
+00091                 nlassert (!str.empty());
+00092 
+00093                 // sorry for this bullshit but it's the simplest way ;)
+00094                 if (this == NULL) return -1;
+00095 
+00096                 for (TStringId i = 0; i < (TStringId) _StringArray.size(); i++)
+00097                 {
+00098                         if (_StringArray[i] == str)
+00099                                 return i;
+00100                 }
+00101 
+00102                 if (!_IgnoreAllUnknownId && !IgnoreIfUnknown)
+00103                 {
+00104                         // the string is not found, add it to the _AskedStringArray if necessary
+00105                         if (_NeedToAskStringArray.find (str) == _NeedToAskStringArray.end ())
+00106                         {
+00107                                 if (_AskedStringArray.find (str) == _AskedStringArray.end ())
+00108                                 {
+00109                                         //nldebug ("String '%s' not found, add it to _NeedToAskStringArray", str.c_str ());     
+00110                                         _NeedToAskStringArray.insert (str);
+00111                                 }
+00112                                 else
+00113                                 {
+00114                                         //nldebug ("Found '%s' in the _AskedStringArray", str.c_str ());        
+00115                                 }
+00116                         }
+00117                         else
+00118                         {
+00119                                 //nldebug ("Found '%s' in the _NeedToAskStringArray", str.c_str ());    
+00120                         }
+00121                 }
+00122                 else
+00123                 {
+00124                         //nldebug ("Ignoring unknown association ('%s')", str.c_str ());        
+00125                 }
+00126 
+00127                 return -1;
+00128         }
+00129 
+00131         std::string getString (TStringId id) const
+00132         {
+00133                 // sorry for this bullshit but it's the simplest way ;)
+00134                 if (this == NULL) return "<NoSIDA>";
+00135 
+00136                 nlassert (id >= 0 && id < (TStringId)_StringArray.size());
+00137 
+00138                 return _StringArray[id];
+00139         }
+00140 
+00142         void resize (TStringId size)
+00143         {
+00144                 _StringArray.resize (size);
+00145         }
+00146 
+00148         TStringId size () const
+00149         {
+00150                 return _StringArray.size ();
+00151         }
+00152 
+00154         const std::set<std::string> &getNeedToAskedStringArray () const
+00155         {
+00156                 return _NeedToAskStringArray;
+00157         }
+00158 
+00160         const std::set<std::string> &getAskedStringArray () const
+00161         {
+00162                 return _AskedStringArray;
+00163         }
+00164 
+00166         void moveNeedToAskToAskedStringArray ()
+00167         {
+00168                 if (!_IgnoreAllUnknownId)
+00169                 {
+00170                         _AskedStringArray.insert (_NeedToAskStringArray.begin(), _NeedToAskStringArray.end());
+00171                         _NeedToAskStringArray.clear ();
+00172                 }
+00173         }
+00174 
+00176         void ignoreAllUnknownId (bool b) { _IgnoreAllUnknownId = b; }
+00177 
+00179         void clear ()
+00180         {
+00181                 _StringArray.clear ();
+00182                 _NeedToAskStringArray.clear ();
+00183                 _AskedStringArray.clear ();
+00184         }
+00185 
+00187         void display ()
+00188         {
+00189                 nlinfo ("static const char *OtherSideAssociations[] = {");
+00190                 for (uint i = 0; i < _StringArray.size(); i++)
+00191                 {
+00192                         nlinfo(" \"%s\",", _StringArray[i].c_str());
+00193                 }
+00194                 nlinfo ("};");
+00195         }
+00196 
+00197 private:
+00198 
+00199         bool _IgnoreAllUnknownId;
+00200 
+00201         std::vector<std::string>        _StringArray;
+00202 
+00203         std::set<std::string>   _NeedToAskStringArray;
+00204 
+00205         std::set<std::string>   _AskedStringArray;
+00206 };
+00207 
+00208 
+00209 } // NLMISC
+00210 
+00211 
+00212 #endif // NL_STRING_ID_ARRAY_H
+00213 
+00214 /* End of string_id_array.h */
+