nevrax.org : docs

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 #include "nel/ai/agent/agent.h"
+00025 
+00026 namespace NLAIAGENT
+00027 {       
+00028         const uint8 CAgentNumber::AgentTypeBit = 1<<7;
+00029         const CAgentNumber CAgentNumber::Unknow(0,CAgentNumber::ServerId,CAgentNumber::ServerId);
+00030 
+00031         uint64 atoiInt64(const char *ident)
+00032         {
+00033                 uint64 k = 0;
+00034 
+00035                 while(*ident != 0)
+00036                 {
+00037                         if(*ident == ':') break;
+00038 
+00039                         switch(*(ident++))
+00040                         {
+00041                         case '0':
+00042                                 k |= 0;
+00043                                 break;
+00044                         case '1':
+00045                                 k |= 1;
+00046                                 break;
+00047                         case '2':
+00048                                 k |= 2;
+00049                                 break;
+00050                         case '3':
+00051                                 k |= 3;
+00052                                 break;
+00053                         case '4':
+00054                                 k |= 4;
+00055                                 break;
+00056                         case '5':
+00057                                 k |= 5;
+00058                                 break;
+00059                         case '6':
+00060                                 k |= 6;
+00061                                 break;
+00062                         case '7':
+00063                                 k |= 7;
+00064                                 break;
+00065                         case '8':
+00066                                 k |= 8;
+00067                                 break;
+00068                         case '9':
+00069                                 k |= 9;
+00070                                 break;
+00071                         case 'a':
+00072                                 k |= 10;
+00073                                 break;
+00074                         case 'b':
+00075                                 k |= 11;
+00076                                 break;
+00077                         case 'c':
+00078                                 k |= 12;
+00079                                 break;
+00080                         case 'd':
+00081                                 k |= 13;
+00082                                 break;
+00083                         case 'e':
+00084                                 k |= 14;
+00085                                 break;
+00086                         case 'f':
+00087                                 k |= 15;
+00088                                 break;
+00089 
+00090                         case 'A':
+00091                                 k |= 10;
+00092                                 break;
+00093                         case 'B':
+00094                                 k |= 11;
+00095                                 break;
+00096                         case 'C':
+00097                                 k |= 12;
+00098                                 break;
+00099                         case 'D':
+00100                                 k |= 13;
+00101                                 break;
+00102                         case 'E':
+00103                                 k |= 14;
+00104                                 break;
+00105                         case 'F':
+00106                                 k |= 15;
+00107                                 break;
+00108 
+00109                         case 0:
+00110                                 return k;
+00111                         case ':':
+00112                                 return k;
+00113                                 break;
+00114                         }
+00115                         if(*ident != 0 && *ident != ':') k <<= 4;
+00116                 }
+00117 
+00118                 return k;
+00119         }       
+00120                 
+00121 
+00122         CLocWordNumRef::~CLocWordNumRef()
+00123         {
+00124                 NLMISC::CSynchronized<tMapRef >::CAccessor a(&_LocRefence);
+00125                 tMapRef::iterator Itr = a.value().find(_Id);
+00126                 if(Itr != a.value().end())
+00127                 {                               
+00128                         a.value().erase(Itr);
+00129                 }
+00130                 else throw NLAIE::CExceptionIndexHandeledError();
+00131         }
+00132 
+00133         const NLAIC::CIdentType &CLocWordNumRef::getType() const
+00134         {               
+00135                 return *IdLocWordNumRef;
+00136         }
+00137 
+00138         IRefrence *CLocWordNumRef::getRef(const CNumericIndex &id)
+00139         {
+00140                 NLMISC::CSynchronized<tMapRef >::CAccessor a(&_LocRefence);
+00141                 tMapRef::iterator Itr = a.value().find(id);
+00142                 if(Itr != a.value().end())
+00143                 {                               
+00144                         return (*Itr).second;
+00145                 }
+00146                 /*else
+00147                 {
+00148                         throw NLAIE::CExceptionIndexHandeledError();
+00149                 }*/
+00150                 return NULL;
+00151         }
+00152 
+00153         void CLocWordNumRef::Init()
+00154         {
+00155                 /*NLMISC::CSynchronized<tMapRef >::CAccessor a(&_LocRefence);
+00156                 a.value() = new CLocWordNumRef::tMapRef;*/
+00157         }
+00158 
+00159         void CLocWordNumRef::clear()
+00160         {                       
+00161                 /*NLMISC::CSynchronized<tMapRef >::CAccessor a(&_LocRefence);
+00162                 if(a.value() )
+00163                 {
+00164                         delete a.value();
+00165                         a.value() = NULL;
+00166                 }*/                     
+00167         }
+00168 
+00169         void releaseAgentLib()
+00170         {
+00171                 //CLocWordNumRef::clear();
+00172                 //CIndexedVarName::releaseClass();
+00173         }
+00174 
+00175         void initAgentLib()
+00176         {
+00177                 CLocWordNumRef::Init();         
+00178                 CIndexedVarName::initClass();
+00179         }       
+00180 }
+
ident.cpp
