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/agentexport.h"
+00025 #include "nel/ai/agent/agent_object.h"
+00026 #include "nel/ai/agent/baseai.h"
+00027 #include "nel/ai/agent/agent_method_def.h"
+00028 #include "nel/ai/agent/object_type.h"
+00029 #include "nel/ai/agent/msg.h"
+00030 #include "nel/ai/agent/agent_local_mailer.h"
+00031 #include "nel/ai/agent/performative.h"
+00032 #include "nel/ai/script/interpret_methodes.h"
+00033 
+00034 namespace NLAIAGENT
+00035 {
+00036         void IConnectIA::save(NLMISC::IStream &os)
+00037         {
+00038                 IRefrence::save(os);
+00039                 tListiBasicCstItr i = _Connection.begin();
+00040                 sint32 size = _Connection.size();
+00041                 os.serial( size );
+00042                 while(i != _Connection.end())
+00043                 {       
+00044                         IWordNumRef &r = (IWordNumRef &)((const IWordNumRef&)*((const IConnectIA *)*i++));
+00045                         os.serial( (NLAIC::CIdentType &) (r.getType()) );
+00046                         r.save(os);
+00047                 }
+00048 
+00049                 i = _Connected.begin();
+00050                 size = _Connected.size(); 
+00051                 os.serial( size );
+00052                 while(i != _Connected.end())
+00053                 {                                               
+00054                         IWordNumRef &r = (IWordNumRef &)((const IWordNumRef&)*((const IConnectIA *)*i++));
+00055                         os.serial( (NLAIC::CIdentType &) (r.getType()) );
+00056                         r.save(os);
+00057                 }
+00058         }       
+00059 
+00062 
+00063         bool CIdMethod::operator < (const CIdMethod &a) const
+00064         {
+00065                 return Weight < a.Weight;
+00066         }
+00067 
+00068         const CIdMethod &CIdMethod::operator = (const CIdMethod &a)
+00069         {
+00070                 Index = a.Index;
+00071                 Weight = a.Weight;
+00072                 Method = a.Method;
+00073                 if(ReturnType != NULL)
+00074                 {
+00075                         ReturnType->release();
+00076                 }
+00077                 ReturnType = a.ReturnType;
+00078                 if(ReturnType != NULL) ReturnType->incRef();
+00079 
+00080                 return *this;
+00081         }
+00082 
+00083         CIdMethod::CIdMethod(const CIdMethod &a)
+00084         {
+00085                 Index = a.Index;
+00086                 Weight = a.Weight;
+00087                 Method = a.Method;              
+00088                 ReturnType = a.ReturnType;
+00089                 if(ReturnType != NULL) 
+00090                         ReturnType->incRef();
+00091         }
+00092         
+00093         CIdMethod::CIdMethod(sint32 i, double w,IObjectIA *m,IObjectIA *r)
+00094         {
+00095                 Index = i;
+00096                 Weight = w;
+00097                 Method = m;
+00098                 ReturnType = r;
+00099         }
+00100 
+00101         CIdMethod::CIdMethod()
+00102         {
+00103                 Method = NULL;
+00104                 ReturnType = NULL;
+00105         }
+00106 
+00107         CIdMethod::~CIdMethod()
+00108         {
+00109                 if(ReturnType != NULL) 
+00110                         ReturnType->release();
+00111         }
+00112 
+00115 
+00116         void IObjectIA::init(IObjectIA *)
+00117         {
+00118                 
+00119         }
+00120 
+00121         IBasicObjectIA::~IBasicObjectIA()
+00122         {
+00123                 //delete _Name;
+00124         }
+00125         
+00126         IBasicObjectIA::IBasicObjectIA()
+00127         {
+00128         }
+00129 
+00130         IBasicObjectIA::IBasicObjectIA(const IBasicObjectIA &a): NLAIC::IBasicInterface(a)
+00131         {
+00132         }
+00133                 
+00134         bool IBasicObjectIA::operator == (const IBasicObjectIA &a) const
+00135         {                                               
+00136                 if(a.getType() == getType() ) return isEqual(a);                        
+00137                 return false;
+00138         }               
+00139 
+00142 
+00143         IObjectIA::CProcessResult IObjectIA::ProcessRun = IObjectIA::CProcessResult();
+00144         IObjectIA::CProcessResult IObjectIA::ProcessNotComplit = IObjectIA::CProcessResult(processNotComplete); 
+00145         TProcessStatement IObjectIA::ProcessIdle = processIdle;
+00146         TProcessStatement IObjectIA::ProcessLocked = processLocked;
+00147         TProcessStatement IObjectIA::ProcessBuzzy = processBuzzy;
+00148         TProcessStatement IObjectIA::ProcessEnd = processEnd;
+00149         TProcessStatement IObjectIA::ProcessError = processError;       
+00150 
+00151         IObjectIA::IObjectIA(const IObjectIA &a):IBasicObjectIA(a)
+00152         {                       
+00153         }
+00154 
+00155         IObjectIA::IObjectIA()
+00156         {                       
+00157         }               
+00158 
+00159         IObjectIA::~IObjectIA()
+00160         {
+00161         }
+00162 
+00163         const IObjectIA::CProcessResult &IObjectIA::runStep()
+00164         {
+00165                 std::string text;
+00166                 text = NLAIC::stringGetBuild("const CProcessResult &IObjectIA::runStep() note implementaited for the '%s' interface",(const char *)getType());
+00167                 throw NLAIE::CExceptionNotImplemented(text.c_str());
+00168                 return IObjectIA::ProcessNotComplit;
+00169         }
+00170 
+00171         IObjectIA &IObjectIA::operator = (const IObjectIA &a)
+00172         {
+00173                 std::string text;
+00174                 text = NLAIC::stringGetBuild("operator <IObjectIA &operator = (const IObjectIA &a)> note implementaited for the '%s' interface",(const char *)getType());
+00175                 throw NLAIE::CExceptionNotImplemented(text.c_str());
+00176                 return *this;
+00177         }
+00178 
+00179 
+00180         sint32 IObjectIA::getStaticMemberSize() const
+00181         {
+00182                 std::string text;
+00183                 text = NLAIC::stringGetBuild("sint32 IObjectIA::getStaticMemberSize() note implementaited for the '%s' interface",(const char *)getType());
+00184                 throw NLAIE::CExceptionNotImplemented(text.c_str());
+00185                 return 0;       
+00186         }
+00187 
+00188         sint32 IObjectIA::getStaticMemberIndex(const IVarName &) const
+00189         {
+00190                 return -1;
+00191         }
+00192 
+00193         const IObjectIA *IObjectIA::getStaticMember(sint32) const
+00194         {
+00195                 return NULL;
+00196         }
+00197 
+00198         bool IObjectIA::setStaticMember(sint32,IObjectIA *)
+00199         {
+00200                 std::string text;
+00201                 text = NLAIC::stringGetBuild("Function void IObjectIA::setStaticMember(sint32,IObjectIA *) note implementaited for the '%s' interface",(const char *)getType());
+00202                 throw NLAIE::CExceptionNotImplemented(text.c_str());
+00203                 return false;
+00204         }
+00205 
+00206         tQueue IObjectIA::isMember(const IVarName *className,const IVarName *methodName,const IObjectIA &param) const
+00207         {               
+00208                 static CStringVarName send(_SEND_);
+00209                 static CStringVarName constructor(_CONSTRUCTOR_);
+00210                 static CStringVarName run(_RUN_);
+00211                 static CStringVarName statM("GetStaticMember");
+00212 
+00213                 if(*methodName == send)
+00214                 {
+00215                         tQueue r;                       
+00216                         CObjectType *c = new CObjectType(new NLAIC::CIdentType(NLAIC::CIdentType::VoidType));
+00217                         r.push(CIdMethod(0,0.0,NULL,c));
+00218                         return r;
+00219                 }
+00220                 else
+00221                 if(*methodName == constructor && !((const NLAISCRIPT::CParam &)param).size())
+00222                 {
+00223                         tQueue r;
+00224                         CObjectType *c = new CObjectType(new NLAIC::CIdentType(NLAIC::CIdentType::VoidType));
+00225                         r.push(CIdMethod(1,0.0,NULL,c));
+00226                         return r;
+00227                 }
+00228                 else
+00229                 if(*methodName == run && !((const NLAISCRIPT::CParam &)param).size())
+00230                 {
+00231                         tQueue r;
+00232                         CObjectType *c = new CObjectType(new NLAIC::CIdentType(NLAIC::CIdentType::VoidType));
+00233                         r.push(CIdMethod(2,0.0,NULL,c));
+00234                         return r;                       
+00235                 }
+00236                 if(*methodName == statM && ((const NLAISCRIPT::CParam &)param).size())
+00237                 {
+00238                         tQueue r;
+00239                         CObjectType *c = new CObjectType(new NLAIC::CIdentType(*IAgent::IdAgent));
+00240                         r.push(CIdMethod(3,0.0,NULL,c));
+00241                         return r;                       
+00242                 }
+00243                 return tQueue();
+00244         }
+00245 
+00246         sint32 IObjectIA::isClassInheritedFrom(const IVarName &) const
+00247         {
+00248                 return -1;
+00249         }       
+00250 
+00251         sint32 IObjectIA::getMethodIndexSize() const
+00252         {
+00253                 return 4;
+00254         }
+00255 
+00256         // Executes a method from its index i and with its parameters
+00257         IObjectIA::CProcessResult IObjectIA::runMethodeMember(sint32 h, sint32 id,IObjectIA *a)
+00258         {
+00259                 /*char text[2048*8];
+00260                 sprintf(text,"method  runMethodeMember(sint32 h, sint32 id,const IObjectIA &) not implemented for the '%s' interface",(const char *)getType());
+00261                 throw NLAIE::CExceptionNotImplemented(text);
+00262                 return CProcessResult();*/
+00263                 return IObjectIA::runMethodeMember(id,a);
+00264         }
+00265 
+00266         IObjectIA::CProcessResult IObjectIA::runMethodeMember(sint32 id,IObjectIA *a)
+00267         {
+00268                 
+00269                 switch(id)
+00270                 {
+00271                 case 0:
+00272                         {
+00273                                 IMessageBase *msg;
+00274 
+00275                                 IPerformative *p;
+00276                                 msg = (IMessageBase *)((IBaseGroupType *)a)->pop();
+00277                                 //this->incRef();
+00278                                 msg->setReceiver(this);
+00279                                 p = (IPerformative *)((IBaseGroupType *)a)->pop();
+00280                                 msg->setPerformatif((IMessageBase::TPerformatif)(sint)p->getNumber());
+00281                                 p->release();
+00282                                 if(((IBaseGroupType *)a)->size())
+00283                                 {                                       
+00284                                         CStringType *name = (CStringType *)((IBaseGroupType *)a)->pop();
+00285                                         IObjectIA::CProcessResult r = sendMessage(name->getStr(),msg);
+00286                                         name->release();
+00287                                         return r;
+00288                                         
+00289                                 }                               
+00290                                 return sendMessage(msg);
+00291                         }                       
+00292                         break;
+00293                 case 1:                 
+00294                         break;
+00295                 case 2:
+00296                         return run();
+00297                         break;
+00298 
+00299                 case 3:
+00300                         {
+00301                                 CProcessResult r;
+00302                                 NLAIAGENT::IBaseGroupType *param = (NLAIAGENT::IBaseGroupType *)a;
+00303                                 r.Result =      (IObjectIA *)getStaticMember((sint)((NLAIAGENT::INombreDefine *)param->get())->getNumber());
+00304                                 r.Result->incRef();
+00305                                 return r;
+00306                         }
+00307                 }
+00308                 return CProcessResult();
+00309         }
+00310 
+00311         std::string IObjectIA::getMethodeMemberDebugString(sint32 h, sint32 id) const
+00312         {
+00313                 switch(id)
+00314                 {
+00315                 case 0:
+00316                         {
+00317                                 return std::string("IObjectIA::sendMessage(IMessage)");
+00318                         }                       
+00319                         break;
+00320                 case 1:                 
+00321                         break;
+00322                 case 2:                 
+00323                         return std::string("IObjectIA::run()");
+00324                         break;
+00325 
+00326                 case 3:
+00327                         {                               
+00328                                 return std::string("IObjectIA::getStaticMember(Integer)");                              
+00329                         }
+00330                 }
+00331                 return std::string("Mathod_?????(Param_?????)");
+00332         }
+00333 
+00334         IObjectIA::CProcessResult IObjectIA::sendMessage(const IVarName &name,IObjectIA *)
+00335         {
+00336                 std::string text;
+00337                 text = NLAIC::stringGetBuild("method 'sendMessage(%s,const IObjectIA &)' '%s' interface",name.getString(), (const char *)getType());
+00338                 throw NLAIE::CExceptionNotImplemented(text.c_str());
+00339                 return CProcessResult();
+00340         }
+00341 
+00342         IObjectIA::CProcessResult IObjectIA::sendMessage(IObjectIA *)
+00343         {
+00344                 std::string text;
+00345                 text = NLAIC::stringGetBuild("method 'sendMessage(const IObjectIA &)' '%s' interface", (const char *)getType());
+00346                 throw NLAIE::CExceptionNotImplemented(text.c_str());
+00347                 return CProcessResult();
+00348         }
+00349 
+00350         tQueue IObjectIA::canProcessMessage(const IVarName &)
+00351         {
+00352                 return tQueue();
+00353         }
+00354 
+00355 
+00356         bool IObjectIA::isLocal()
+00357         {
+00358                 return true;
+00359         }
+00360 
+00363 
+00364         IRefrence::IRefrence():_Parent(NULL)
+00365         {
+00366                 _NumRef = new CLocWordNumRef(this);
+00367         }
+00368 
+00369         IRefrence::IRefrence(const IWordNumRef *parent):_Parent((IWordNumRef *)parent)
+00370         {
+00371                 //if(_Parent != NULL) _Parent->incRef();
+00372                 _NumRef = new CLocWordNumRef(this);
+00373         }
+00374 
+00375         IRefrence::IRefrence(NLMISC::IStream &is)
+00376         {
+00377                 refLoadStream(is);
+00378         }
+00379 
+00380         IRefrence::operator const IWordNumRef &() const
+00381         {
+00382                 return *_NumRef;
+00383         }
+00384 
+00385         IRefrence::operator const IWordNumRef *() const 
+00386         {
+00387                 return _NumRef;
+00388         }
+00389 
+00390         IRefrence *IRefrence::getParent() const
+00391         {
+00392                 return _Parent != NULL ? (IRefrence *)((const IRefrence *)*_Parent) : NULL;
+00393         }
+00394 
+00395         void IRefrence::setParent(const IWordNumRef *parent)
+00396         {
+00397                 //if(_Parent != NULL) _Parent->release();
+00398                 _Parent = (IWordNumRef *)parent;
+00399                 //if(_Parent != NULL) _Parent->incRef();                
+00400         }
+00401 
+00402         const IRefrence *IRefrence::getOwner() const
+00403         {
+00404                 const IRefrence *p = getParent();
+00405 
+00406                 if(p == NULL) return this;
+00407 
+00408                 while( true )
+00409                 {
+00410                         if(p->getParent() == NULL) return p;
+00411                 }
+00412         }
+00413 
+00414         void IRefrence::save(NLMISC::IStream &os)
+00415         {
+00416                 IObjectIA::save(os);
+00417                 os.serial( (NLAIC::CIdentType &) (_NumRef->getType()) );
+00418                 _NumRef->save(os);
+00419                 if(_Parent != NULL)
+00420                 {
+00421                         bool t = true;
+00422                         os.serial( t );
+00423                         os.serial( (NLAIC::CIdentType &) (_Parent->getType()) );
+00424                         _Parent->save(os);
+00425                 }
+00426                 else
+00427                 {
+00428                         bool t =  false;
+00429                         os.serial( t ); 
+00430                 }
+00431         }
+00432 
+00433         void IRefrence::refLoadStream(NLMISC::IStream &is)
+00434         {
+00435                 IObjectIA::load(is);
+00436                 _NumRef->release();
+00437                 NLAIC::CIdentTypeAlloc id;
+00438                 is >> id;
+00439                 _NumRef = (IWordNumRef *)id.allocClass();
+00440                 _NumRef->load(is);
+00441                 bool k;
+00442                 is.serial( k );
+00443                 if ( k ) 
+00444                 {
+00445                         if(_Parent) _Parent->release();
+00446                         is >> id;
+00447                         _Parent = (IWordNumRef *)id.allocClass();
+00448                         _Parent->load(is);
+00449                 }
+00450                 else 
+00451                 {
+00452                         _Parent = NULL;
+00453                 }
+00454         }
+00455 
+00456         void IRefrence::load(NLMISC::IStream &is)
+00457         {
+00458                 refLoadStream(is);
+00459         }
+00460 
+00461         void IRefrence::setNumRef(const IWordNumRef &ref)
+00462         {
+00463                 if(_NumRef != NULL) _NumRef->release();
+00464                 _NumRef = new CLocWordNumRef(ref.getNumIdent(),this);
+00465         }
+00466 
+00467         IRefrence::~IRefrence()
+00468         {
+00469                 //if(_Parent != NULL) _Parent->release();
+00470                 _NumRef->release();
+00471         }
+00472 
+00473         IRefrence::IRefrence(const IRefrence &A):IObjectIA(A),_Parent(A._Parent)//,_NumRef(A._NumRef)
+00474         {                       
+00475                 //if(_Parent != NULL) _Parent->incRef();
+00476                 _NumRef = new CLocWordNumRef(this);
+00477                 setTypeAt(A._NumRef->getNumIdent().getId().getType());
+00478         }               
+00479 
+00480         const CIdent IRefrence::getIdentType() const
+00481         {
+00482                 return CIdent(0,_NumRef->getNumIdent().getId());
+00483         }
+00484 
+00485         void IRefrence::setTypeAt(uint64 t)
+00486         {
+00487                 ((CAgentNumber &)(_NumRef->getNumIdent().getId())).setTypeAt(t);
+00488         }
+00489 
+00490 
+00493 
+00494         IConnectIA::IConnectIA(const IConnectIA &A):IRefrence(A)
+00495         {
+00496         }
+00497 
+00498         IConnectIA::IConnectIA():IRefrence()
+00499         {
+00500         }
+00501 
+00502         IConnectIA::IConnectIA(const IWordNumRef *parent):IRefrence(parent)
+00503         {
+00504         }               
+00505 
+00506         IConnectIA::IConnectIA(NLMISC::IStream &is):IRefrence(is)
+00507         {
+00508                 connectLoadStream(is);
+00509         }
+00510 
+00511         IConnectIA *IConnectIA::getParent() const
+00512         {
+00513                 return (IConnectIA *)IRefrence::getParent();
+00514         }       
+00515 
+00516         void IConnectIA::load(NLMISC::IStream &is)
+00517         {
+00518                 connectLoadStream(is);
+00519         }
+00520 
+00521         void IConnectIA::connectLoadStream(NLMISC::IStream &is)
+00522         {
+00523                 IRefrence::refLoadStream(is);
+00524                 NLAIC::CIdentTypeAlloc id;
+00525                 sint32 i;
+00526                 is.serial( i );
+00527 
+00528                 if(i)
+00529                 {
+00530                         while(i --)
+00531                         {                                       
+00532                                 is >> id;
+00533                                 IWordNumRef *num = (IWordNumRef *)id.allocClass();
+00534                                 num->load(is);
+00535                                 addInConnectionList((IConnectIA *)((const IRefrence *)*num));
+00536                                 delete num; 
+00537                         }
+00538                 }
+00539 
+00540                 
+00541                 is.serial(i);
+00542                 if(i)
+00543                 {
+00544                         while(i--)
+00545                         {
+00546                                 is >> id;                                       
+00547                                 IWordNumRef *num = (IWordNumRef *)id.allocClass();
+00548                                 num->load(is);
+00549                                 addInConnectedList((IConnectIA *)((const IRefrence *)*num));
+00550                                 delete num;
+00551                         }
+00552                 }
+00553         }
+00554 
+00555         void IConnectIA::connect(IConnectIA *b)
+00556         {
+00557                 b->addInConnectedList(this);
+00558                 addInConnectionList(b);
+00559         }
+00560 
+00561         void IConnectIA::removeConnection(IConnectIA *Agent)
+00562         {               
+00563                 Agent->removeInConnectedList(this);
+00564                 removeInConnectionList(Agent);                  
+00565         }
+00566 
+00567         IConnectIA::~IConnectIA()
+00568         {
+00569                 Kill();
+00570         }
+00571 
+00572         void IConnectIA::addInConnectionList(const IConnectIA *a)
+00573         {
+00574                 _Connection.insert(a);
+00575         }
+00576 
+00577         void IConnectIA::removeInConnectionList(IConnectIA *a)
+00578         {
+00579 
+00580                 tListiBasicItr i = _Connection.find(a);
+00581                 if(i != _Connection.end())
+00582                                                         _Connection.erase(i);
+00583                 /*tListiBasicItr i = _Connection.begin();
+00584                 while(i != _Connection.end())
+00585                 {                               
+00586                         if(*i == a)
+00587                         {
+00588                                 _Connection.erase(i);
+00589                                 return;
+00590                         }
+00591                         i++;
+00592                 }*/
+00593         }
+00594 
+00595         void IConnectIA::addInConnectedList(const IConnectIA *a)
+00596         {
+00597                 _Connected.insert(a);
+00598         }
+00599 
+00600         void IConnectIA::removeInConnectedList(const IConnectIA *a)
+00601         {
+00602                 tListiBasicItr i = _Connected.find(a);
+00603                 if(i != _Connected.end())
+00604                                                 _Connected.erase(i);
+00605                 /*tListiBasicItr i = _Connected.begin();
+00606                 while(i != _Connected.end())
+00607                 {                       
+00608                         const IConnectIA *o = *i;
+00609                         if(o == a)
+00610                         {                                       
+00611                                 _Connected.erase(i);
+00612                                 return;
+00613                         }
+00614                         i++;
+00615                 }*/
+00616         }
+00617 
+00618         void IConnectIA::Kill()
+00619         {
+00620                 IConnectIA *parent = getParent();
+00621                 if ( parent != NULL )
+00622                 {
+00623                         parent->onKill( this );
+00624                 }
+00625 
+00626                 tListiBasicCstItr it = _Connection.begin();
+00627 
+00628                 while(it != _Connection.end())
+00629                 {                               
+00630                         IConnectIA *a = (IConnectIA *)*it ++;                   
+00631                         if(a != NULL)
+00632                         {
+00633                                 a->removeInConnectedList(this);
+00634                         }
+00635                 }
+00636                 _Connection.clear();
+00637 
+00638                 it = _Connected.begin();
+00639                 while(it != _Connected.end())
+00640                 {                               
+00641                         IConnectIA *a = (IConnectIA *)*it ++;                   
+00642                         if(a != NULL)
+00643                         {
+00644                                 a->removeInConnectionList(this);
+00645                                 a->onKill(this);                                
+00646                         }
+00647                 }
+00648                 _Connected.clear();
+00649         }
+00650 
+00651         void IConnectIA::onKill(IConnectIA *a)
+00652         {
+00653                 IConnectIA *parent = getParent();
+00654                 if ( parent == a )
+00655                 {
+00656                         //parent->release();
+00657                         setParent(NULL);
+00658                 }
+00659         }
+00660 
+00661         void IConnectIA::setParent(const IWordNumRef *parent)
+00662         {               
+00663                 IRefrence::setParent(parent);
+00664                 IConnectIA *p = (IConnectIA *)getParent();
+00665 
+00666                 if(p != NULL) connect(p);
+00667         }
+00668 }
+
baseai.cpp
