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 
+00027 #ifndef NL_IDENTTYPE_H
+00028 #define NL_IDENTTYPE_H
+00029 #include <stdlib.h>
+00030 #include "nel/misc/file.h"
+00031 #include "nel/misc/entity_id.h"
+00032 #include "nel/ai/e/ai_exception.h"
+00033 #include "nel/ai/agent/agent_string.h"
+00034 
+00035 namespace NLAIAGENT
+00036 {       
+00037 #ifndef _MAX__INDEX_DEFINED
+00038                 const sint32 maxIndex = 2;
+00039                 #define _MAX__INDEX_DEFINED
+00040 
+00041                 const uint64 maxResolutionNumer = ((uint64)2 << 48) - (uint64)1;
+00042 #else
+00043                 extern const sint32 maxIndex;
+00044                 extern const uint64 maxResolutionNumer;
+00045 #endif
+00046 
+00047         struct CAgentNumber: public NLMISC::CEntityId
+00048         {               
+00051                 static const uint8 AgentTypeBit;                
+00052 
+00053                 CAgentNumber()
+00054                 {
+00055                         setType( CAgentNumber::AgentTypeBit );
+00056                 }
+00057                 CAgentNumber(uint64 id,uint8 creator,uint8 dyn):NLMISC::CEntityId(AgentTypeBit,id,creator,dyn)
+00058                 {                       
+00059                 }
+00060 
+00061                 CAgentNumber(uint64 id, uint8 t,uint8 creator,uint8 dyn):NLMISC::CEntityId(t,id,creator,dyn)
+00062                 {               
+00063                 }
+00064 
+00065                 CAgentNumber(uint64 p):NLMISC::CEntityId(p)
+00066                 {
+00067                 }
+00068 
+00069                 CAgentNumber(const CAgentNumber &a):NLMISC::CEntityId(a)
+00070                 {
+00071                 }
+00072 
+00073                 CAgentNumber(NLMISC::IStream &is):NLMISC::CEntityId(is)
+00074                 {
+00075                 }
+00076 
+00077                 CAgentNumber(const char *id):NLMISC::CEntityId(id)
+00078                 {
+00079                 }
+00080 
+00081                 bool isAgentId() const
+00082                 {
+00083                         return (getType() & AgentTypeBit) != 0;
+00084                 }
+00085 
+00086                 virtual bool operator < (const NLMISC::CEntityId &a) const
+00087                 {
+00088                         
+00089                         if(isAgentId())
+00090                         {
+00091                                 if (getShortId() < a.getShortId())
+00092                                 {
+00093                                         return true;
+00094                                 }
+00095                                 else 
+00096                                 if (getShortId() == a.getShortId())
+00097                                 {
+00098                                         if(getCreatorId() < a.getCreatorId())
+00099                                         {
+00100                                                 return true;
+00101                                         }
+00102                                         else
+00103                                                 if(getCreatorId() == a.getCreatorId())
+00104                                                 {
+00105                                                         return getDynamicId() < a.getDynamicId();
+00106                                                 }
+00107                                 }
+00108                                 return false;
+00109                         }
+00110                         else
+00111                         {
+00112                                 return CEntityId::operator < (a);
+00113                         }
+00114                 }
+00115 
+00117                 void setTypeAt(uint64 t)
+00118                 {
+00119                         uint8 type = getType();
+00120                         type |= (t & 0x7f);
+00121                         setType( type );
+00122                 }
+00123 
+00124         };
+00125 
+00126         /*struct CAgentNumber: public NLMISC::IStreamable
+00127         {
+00128                 static uint8 ServerID;
+00129 
+00131                 uint64  DynamicId   :  8;
+00133                 uint64  CreatorId   :  8;
+00135                 uint64  AgentNumber : 48;
+00136 
+00137                 CAgentNumber()
+00138                 {
+00139                         CreatorId = (uint64)ServerID;
+00140                         DynamicId = (uint64)ServerID;
+00141                         AgentNumber = 0;
+00142                 }               
+00143 
+00144                 CAgentNumber(uint64 id,uint64 creator,uint64 dyn)
+00145                 {
+00146                         CreatorId = creator;
+00147                         DynamicId = dyn;
+00148                         AgentNumber = id;
+00149                 }
+00150 
+00151                 CAgentNumber(uint64 p)
+00152                 {                       
+00153                         DynamicId = (uint64)(p & 0xff);
+00154                         p >>= 8;
+00155                         CreatorId = (uint64)(p & 0xff);
+00156                         p >>= 8;
+00157                         AgentNumber = (uint64)(p);                      
+00158                 }
+00159 
+00160                 CAgentNumber(const CAgentNumber &a)
+00161                 {
+00162                         CreatorId = a.CreatorId;                        
+00163                         DynamicId = a.DynamicId;
+00164                         AgentNumber = a.AgentNumber;
+00165                 }
+00166 
+00168                 CAgentNumber(NLMISC::IStream &is)
+00169                 {
+00170                         uint64 p;
+00171                         is.serial(p);
+00172 
+00173                         DynamicId = (uint64)(p & 0xff);
+00174                         p >>= 8;
+00175                         CreatorId = (uint64)(p & 0xff);
+00176                         p >>= 8;
+00177                         AgentNumber = (uint64)(p);                      
+00178                 }
+00179 
+00180                 CAgentNumber(const char *id);
+00181 
+00183 
+00184                 bool operator == (const CAgentNumber &a) const
+00185                 {                       
+00186                         return (AgentNumber == a.AgentNumber && CreatorId == a.CreatorId);                      
+00187                 }
+00188                                 
+00189                 bool operator < (const CAgentNumber &a) const
+00190                 {                       
+00191                         if(AgentNumber < a.AgentNumber) return true; 
+00192                         else
+00193                         if(AgentNumber == a.AgentNumber) return (CreatorId < a.CreatorId);
+00194 
+00195                         return false;
+00196                 }
+00197 
+00198                 bool operator > (const CAgentNumber &a) const
+00199                 {                       
+00200                         if(AgentNumber > a.AgentNumber) return true; 
+00201                         else
+00202                         if(AgentNumber == a.AgentNumber) return (CreatorId > a.CreatorId);
+00203 
+00204                         return false;
+00205                 }
+00207 
+00208                 const CAgentNumber &operator ++(int)
+00209                 {
+00210                         if(AgentNumber < maxResolutionNumer)
+00211                         {
+00212                                 AgentNumber ++;
+00213                         }
+00214                         else
+00215                         {
+00216                                 throw NLAIE::CExceptionIndexError();
+00217                         }
+00218                         return *this;
+00219                 }
+00220 
+00221                 const CAgentNumber &operator = (const CAgentNumber &a)
+00222                 {
+00223                         CreatorId = a.CreatorId;                        
+00224                         DynamicId = a.DynamicId;
+00225                         AgentNumber = a.AgentNumber;
+00226                         return *this;
+00227                 }
+00228 
+00229                 const CAgentNumber &operator = (uint64 p)
+00230                 {                       
+00231                         DynamicId = (uint64)(p & 0xff);
+00232                         p >>= 8;
+00233                         CreatorId = (uint64)(p & 0xff);
+00234                         p >>= 8;
+00235                         AgentNumber = (uint64)(p);
+00236                         
+00237                         return *this;
+00238                 }
+00239 
+00240                 operator uint64 () const
+00241                 {
+00242                         uint64 p = AgentNumber;
+00243                         p <<= 8;
+00244                         p |= (uint64)CreatorId;
+00245                         p <<= 8;
+00246                         p |= (uint64)DynamicId;
+00247 
+00248                         return p;
+00249                 }
+00250 
+00252                 virtual void save(NLMISC::IStream &os)
+00253                 {                       
+00254                         uint64 p = AgentNumber;
+00255                         p <<= 8;
+00256                         p |= (uint64)CreatorId;
+00257                         p <<= 8;
+00258                         p |= (uint64)DynamicId;
+00259                         os.serial(p);                   
+00260                 }
+00261 
+00263                 virtual void load(NLMISC::IStream &is)
+00264                 {
+00265                         uint64 p;
+00266                         is.serial(p);
+00267 
+00268                         DynamicId = (uint64)(p & 0xff);
+00269                         p >>= 8;
+00270                         CreatorId = (uint64)(p & 0xff);
+00271                         p >>= 8;
+00272                         AgentNumber = (uint64)(p);                      
+00273 
+00274                 }
+00275 
+00276                 
+00278                 virtual void getDebugString(std::string &str) const;            
+00279 
+00281 
+00282                 virtual std::string     getClassName()
+00283                 {
+00284                         return std::string("<CAgentNumber>");
+00285                 }
+00286 
+00287                 virtual void serial(NLMISC::IStream     &f) throw(NLMISC::EStream)
+00288                 {
+00289                         if(f.isReading())
+00290                         {
+00291                                 load(f);
+00292                         }
+00293                         else
+00294                         {                               
+00295                                 save(f);
+00296                         }
+00297 
+00298                 }
+00300 
+00301         };      */
+00302 
+00308         struct CIdent: public CAgentNumber
+00309         {
+00310                 std::string TypeName;
+00311                 CIdent()
+00312                 {                       
+00313                 }               
+00314 
+00315                 CIdent(const std::string &typeName,uint64 id,uint8 creator = ServerId,uint8 dyn = ServerId):CAgentNumber(id,creator,dyn),TypeName(typeName)
+00316                 {                       
+00317                 }
+00318 
+00319                 CIdent(const std::string &typeName,const CAgentNumber &a):CAgentNumber(a),TypeName(typeName)
+00320                 {                       
+00321                 }
+00322 
+00323                 CIdent(const CIdent &a):CAgentNumber(a),TypeName(a.TypeName)
+00324                 {                       
+00325                 }
+00326 
+00328                 CIdent(NLMISC::IStream &is):CAgentNumber(is)
+00329                 {                       
+00330                         std::string s;
+00331                         is.serial(s);
+00332                         TypeName = s;
+00333                 }
+00334 
+00335                 virtual ~CIdent() {}
+00336 
+00337                 bool operator == (const CIdent &a) const
+00338                 {
+00339                         if(TypeName == a.TypeName) 
+00340                         {
+00341                                 return CAgentNumber::operator == (a);
+00342                         }
+00343                         return false;
+00344                 }
+00345                                 
+00346                 bool operator < (const CIdent &a) const
+00347                 {                               
+00348                         return TypeName < a.TypeName;
+00349                 }
+00350 
+00351                 bool operator > (const CIdent &a) const
+00352                 {
+00353                         return !(TypeName < a.TypeName);
+00354                 }               
+00355                 
+00356 
+00357                 const CIdent &operator = (const CIdent &a)
+00358                 {
+00359                         CAgentNumber::operator = (a);
+00360                         TypeName = a.TypeName;
+00361                         return *this;
+00362                 }
+00363 
+00365                 virtual void save(NLMISC::IStream &os)
+00366                 {       
+00367                         CAgentNumber::save(os);
+00368                         os.serial(TypeName);
+00369                 }
+00370 
+00372                 virtual void load(NLMISC::IStream &is)
+00373                 {
+00374                         CAgentNumber::load(is);
+00375                         std::string s;
+00376                         is.serial(s);
+00377                         TypeName = s;
+00378                 }
+00379 
+00380                 
+00381 
+00383                 virtual void getDebugString(std::string &str) const
+00384                 {
+00385                         CAgentNumber::getDebugString(str);
+00386                         str += NLAIC::stringGetBuild(" '%s'",TypeName.data());
+00387                 }
+00388 
+00389                 const std::string &getTypeName() const
+00390                 {
+00391                         return TypeName;
+00392                 }
+00393         };
+00394 }
+00395 #endif
+
identtype.h
