# Home    # nevrax.com   
Nevrax
Nevrax.org
#News
#Mailing-list
#Documentation
#CVS
#Bugs
#License
Docs
 
Documentation  
Main Page   Namespace List   Class Hierarchy   Alphabetical List   Compound List   File List   Namespace Members   Compound Members   File Members   Related Pages   Search  

agent_string.h

Go to the documentation of this file.
00001 
00006 /* Copyright, 2000 Nevrax Ltd.
00007  *
00008  * This file is part of NEVRAX NEL.
00009  * NEVRAX NEL is free software; you can redistribute it and/or modify
00010  * it under the terms of the GNU General Public License as published by
00011  * the Free Software Foundation; either version 2, or (at your option)
00012  * any later version.
00013 
00014  * NEVRAX NEL is distributed in the hope that it will be useful, but
00015  * WITHOUT ANY WARRANTY; without even the implied warranty of
00016  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
00017  * General Public License for more details.
00018 
00019  * You should have received a copy of the GNU General Public License
00020  * along with NEVRAX NEL; see the file COPYING. If not, write to the
00021  * Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
00022  * MA 02111-1307, USA.
00023  */
00024 #ifndef NL_AGENT_STRING_H
00025 #define NL_AGENT_STRING_H
00026 #include <list>
00027 
00028 namespace NLAIAGENT
00029 {       
00037         class IVarName: public NLAIC::IBasicInterface
00038         {
00039         public:
00040 
00041                 IVarName()
00042                 {
00043                 }
00044 
00046                 virtual const char *getString() const = 0;              
00047 
00049 
00050                 bool operator < (const IVarName &v) const
00051                 {                       
00052                         const char *name1 = getString();
00053                         const char *name2 = v.getString();
00054                         if(name1[0] < name2[0]) return true;
00055                         else return strcmp(name1,name2) < 0;                    
00056                 }
00057 
00058                 bool operator > (const IVarName &v) const
00059                 {                       
00060                         const char *name1 = getString();
00061                         const char *name2 = v.getString();
00062                         if(name1[0] > name2[0]) return true;
00063                         else return strcmp(name1,name2) > 0;
00064                 }
00065 
00066 
00067                 bool operator == (const IVarName &v) const
00068                 {
00069                         const char *name1 = getString();
00070                         const char *name2 = v.getString();
00071                         if(name1[0] == name2[0]) return strcmp(name1,name2) == 0;
00072                         
00073                         return false;
00074                 }
00076 
00078                 const char *addString(const IVarName &s) const 
00079                 {
00080                         char *nameTmp,*str = (char *)s.getString();             
00081                         nameTmp = (char *)getString();  
00082                         char *name = new char [strlen(str) + strlen(nameTmp) + 2];
00083                         sprintf(name,"%s%s",nameTmp,str);                       
00084                         return name;
00085                 }
00086 
00088                 const char *subString(const IVarName &s) const 
00089                 {
00090                         char *nameTmp,*str = (char *)s.getString();             
00091                         nameTmp = (char *)getString();  
00092 
00093                         sint32 k = strlen(nameTmp);
00094 
00095                         for(sint32 i = 0; i < k; i ++)
00096                         {
00097                                 if(!strcmp(&nameTmp[i],str))
00098                                 {
00099                                         sint32 l,n = strlen(str);
00100                                         char *name = new char [(l = (k - n + 1))];
00101                                         memcpy(name,nameTmp,i);
00102                                         memcpy(&name[i],nameTmp + n,l);
00103                                         return name;
00104                                 }
00105                         }
00106                         return NULL;
00107                 }
00108 
00110 
00111                 virtual IVarName &operator += (const IVarName &s) = 0;
00112                 virtual IVarName &operator -= (const IVarName &s) = 0;
00113                 virtual IVarName &operator = (const IVarName &v) = 0;           
00115 
00116                 virtual ~IVarName()
00117                 {
00118                 }       
00119                 //virtual typeVarName getEnumType() const = 0;
00120                 
00121         };              
00122 
00130         class CStringVarName : public IVarName
00131         {
00132         public:
00133                 static const NLAIC::CIdentType IdStringVarName;
00134         private:
00135                 char *_Name;
00136         public:
00137                 CStringVarName(const char *name)
00138                 {
00139                         sint32 i = strlen(name) + 1;
00140                         _Name =  new char [i];
00141                         if(i == 1)
00142                         {
00143                                 _Name[0] = 0;
00144                         }                       
00145                         else memcpy(_Name,name,i);
00146                 }
00147 
00148                 CStringVarName(const CStringVarName &s)
00149                 {
00150                         sint32 i = strlen(s._Name) + 1;
00151                         _Name =  new char [i];
00152                         if(i == 1)
00153                         {
00154                                 _Name[0] = 0;
00155                         }                       
00156                         else memcpy(_Name,s._Name,i);
00157                 }
00158 
00159                 CStringVarName(NLMISC::IStream &is):_Name(NULL)
00160                 {
00161                         load(is);
00162                 }
00163                 
00164 
00165                 virtual ~CStringVarName()
00166                 {
00167                         delete []_Name;
00168                 }       
00169 
00170                 virtual  const char *getString() const
00171                 {
00172                         return _Name;
00173                 }               
00174 
00175                 const NLAIC::CIdentType &getType() const;
00176                 
00177 
00178                 void save(NLMISC::IStream &os)
00179                 {                       
00180                         uint32 size = strlen(_Name) + 1;
00181                         os.serial( size );
00182                         std::string x = std::string(_Name);
00183                         os.serial( x );
00184                 }
00185 
00186                 void load(NLMISC::IStream &is)
00187                 {
00188                         uint32 i;               
00189                         is.serial(i);
00190                         if(_Name != NULL) delete []_Name;
00191                         _Name =  new char [i];
00192                         std::string name;
00193                         is.serial( name );      
00194                         strcpy(_Name, name.c_str() );
00195                 }               
00196 
00197                 IVarName &operator += (const IVarName &s)
00198                 {
00199                         char *nameTmp = (char *)addString(s);
00200                         delete _Name;
00201                         _Name = nameTmp;                        
00202                         return *this;
00203                 }               
00204                 
00205                 IVarName &operator -= (const IVarName &s)
00206                 {                       
00207                         char *n = (char *)subString(s);
00208                         if(n)
00209                         {
00210                                 delete _Name;
00211                                 _Name = n;
00212                         }                               
00213                         return *this;
00214                 }
00215                 
00216                 IVarName &operator = (const IVarName &v)
00217                 {
00218                         delete _Name;
00219                         sint32 i = strlen(v.getString()) + 1;
00220                         _Name =  new char [i];
00221                         memcpy(_Name,v.getString(),i);
00222                         return *this;
00223                 }
00224 
00225                 CStringVarName &operator = (const CStringVarName &v)
00226                 {
00227                         delete _Name;
00228                         sint32 i = strlen(v.getString()) + 1;
00229                         _Name =  new char [i];
00230                         memcpy(_Name,v.getString(),i);
00231                         return *this;
00232                 }
00233 
00234                 const NLAIC::IBasicType *clone() const
00235                 {
00236                         NLAIC::IBasicInterface *m = new CStringVarName(_Name);
00237                         return m;
00238                 }
00239 
00240                 const NLAIC::IBasicType *newInstance() const
00241                 {                       
00242                         return clone();
00243                 }
00244 
00245                 void getDebugString(char *text) const
00246                 {
00247                         sprintf(text,"'%s'",_Name);
00248                 }
00249         };      
00250 
00259         class CIndexedVarName : public IVarName
00260         {
00261 
00262         public:
00263                 static const NLAIC::CIdentType IdIndexedVarName;
00264         private:
00266                 struct CNameStruc
00267                 {
00269                         sint32 Count;
00271                         sint32 Index;
00273                         CStringVarName *Name;
00274                         
00275 
00276                         CNameStruc():Count(0),Index(0),Name(NULL) {}
00277                         CNameStruc(CStringVarName *name,sint32 index):Count(0),Index(index),Name(name){}
00279                         const sint32  &inc()
00280                         {
00281                                 return ++Count;
00282                         }
00284                         const sint32  &dec()
00285                         {
00286                                 return --Count;
00287                         }
00288 
00289                         virtual void save(NLMISC::IStream &)
00290                         {
00291                                 // TODO
00292 /*                              os.serial( Count );
00293                                 os.serial( Index );
00294                                 os.serial( *Name );*/
00295                         }
00296 
00297                         virtual void load(NLMISC::IStream &)
00298                         {
00299 /*                              is.serial(Count);
00300                                 is.serial(Index);                               
00301                                 if(Name == NULL) 
00302                                         Name = new CStringVarName(is);
00303                                 is.serial(Name);*/
00304                         }
00305                 };              
00306                 
00308                 typedef std::map<CStringVarName ,CNameStruc *> tMapName;
00309 
00310         private:
00311 
00313                 static tMapName *_Map;
00315                 static CNameStruc *_TableName;
00320                 static const sint32 _Bank;
00321 
00323                 static sint32 _Count;
00327                 static std::list<CNameStruc *> *_Empty;
00328 
00329         private:
00331                 sint32 _Index;
00332 
00333         public:
00334                 CIndexedVarName(const char *name);
00335                 CIndexedVarName(const CIndexedVarName &name);
00336                 CIndexedVarName(NLMISC::IStream &is);
00337 
00338 
00339                 sint32 newIndex();
00340                 
00341                 const char *getString() const;
00342 
00343                 const NLAIC::CIdentType &getType() const;       
00344 
00345                 const sint32 &getIndex() const
00346                 {
00347                         return _Index;
00348                 }
00349 
00350                 IVarName &operator += (const IVarName &s);              
00351 
00352                 IVarName &operator -= (const IVarName &s);
00353 
00354                 IVarName &operator = (const IVarName &v);               
00355 
00356                 void save(NLMISC::IStream &os);
00357                 void load(NLMISC::IStream &is);
00358                 const NLAIC::IBasicType *clone() const;
00359                 const NLAIC::IBasicType *newInstance() const;
00360                 void getDebugString(char *text) const;
00361 
00362                 ~CIndexedVarName();
00363 
00364         private:
00366                 void insert(const CStringVarName &name);
00368                 void clear();
00369 
00370         public:
00371                 static void initClass();
00372                 static void saveClass(NLMISC::IStream &is);
00373                 static void loadClass(NLMISC::IStream &is);
00374                 static void releaseClass();
00375         };
00376 }
00377 #endif