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 #include "nel/ai/agent/object_type.h"
+00026 #include "nel/ai/agent/agent_local_mailer.h"
+00027 #include "nel/ai/agent/agent_digital.h"
+00028 #include "nel/ai/agent/agent_method_def.h"
+00029 #include "nel/ai/script/interpret_object_message.h"
+00030 #include "nel/ai/script/interpret_object_agent.h"
+00031 #include "nel/ai/script/type_def.h"
+00032 #include "nel/ai/agent/msg_notify.h"
+00033 #include "nel/ai/agent/object_ident.h"
+00034 
+00035 namespace NLAIAGENT
+00036 {
+00037 
+00038         IAgent::IAgent(const IAgent &a) : IAgentComposite(a)
+00039         {
+00040                 _Iter_Child = _AgentList.begin();
+00041         }
+00042 
+00043         IAgent::IAgent(IBasicAgent *parent): IAgentComposite(parent)
+00044         {                       
+00045                 _Iter_Child = _AgentList.begin();
+00046         }
+00047 
+00048         IAgent::IAgent(IBasicAgent *parent,IMailBox *m): IAgentComposite(parent,m)
+00049         {                       
+00050                 _Iter_Child = _AgentList.begin();
+00051         }
+00052 
+00053 /*      const IObjectIA::CProcessResult &IAgent::run();
+00054         IObjectIA *IAgent::run(const IMessageBase &);*/
+00055                 
+00056 
+00057         void IAgent::Kill()
+00058         {
+00059 //sint n = _SizeChild;
+00060 
+00061 #ifdef NL_DEBUG
+00062                 if(_SizeChild != (sint)_AgentList.size())
+00063                 {
+00064                         sint i = (sint)_AgentList.size();
+00065                         throw;
+00066                 }
+00067 
+00068         nlinfo (" Kill 0x0%0x", this);
+00069 
+00070 #endif
+00071                 sint n = _SizeChild ;
+00072                 while ( /*_AgentList.begin() !=  _AgentList.end()*/ n--)
+00073                 {                                       
+00074                         IConnectIA *c = _AgentList.front();
+00075                         _AgentList.pop_front();
+00076                         c->onKill(this);
+00077                         c->release();                   
+00078                 }
+00079                 _SizeChild = 0;
+00080                 IAgentComposite::Kill();
+00081         }
+00082 
+00083         void IAgent::onKill(IConnectIA *a)
+00084         {
+00085                 if(eraseFromList<IBasicAgent *>(&_AgentList,(IBasicAgent *)a)) 
+00086                 {
+00087                         a->release();
+00088                         _SizeChild --;
+00089                 }
+00090                 removeConnection(a);            
+00091                 IAgentComposite::onKill(a);             
+00092         }
+00093 
+00094         const NLAIC::IBasicType *IAgent::clone() const
+00095         {               
+00096                 NLAIC::IBasicInterface *m = new IAgent(*this);
+00097                 return m;
+00098         }               
+00099 
+00100         const NLAIC::IBasicType *IAgent::newInstance() const
+00101         {       
+00102                 NLAIC::IBasicInterface *m;
+00103                 if(getParent() != NULL) m = new IAgent((IBasicAgent *)getParent());
+00104                 else m = new IAgent(NULL);
+00105                 return m;
+00106         }
+00107         
+00108         void IAgent::getDebugString(std::string &t) const
+00109         {
+00110                 t += NLAIC::stringGetBuild("class IAgent<%4x>",this);
+00111         }
+00112 
+00113         bool IAgent::isEqual(const IBasicObjectIA &a) const
+00114         {
+00115                 return true;
+00116         }
+00117 
+00118         /*const NLAIC::CIdentType &IAgent::getType() const;             
+00119         void IAgent::save(NLMISC::IStream &os);
+00120         void IAgent::load(NLMISC::IStream &is);*/
+00121 
+00122         IAgent::~IAgent()
+00123         {
+00124                 Kill(); 
+00125         }                       
+00126         
+00127         void IAgent::save(NLMISC::IStream &os)
+00128         {                               
+00129                 IBasicAgent::save(os);
+00130                 IAgentComposite::save(os);
+00131         }
+00132 
+00133         void IAgent::load(NLMISC::IStream &is)
+00134         {       
+00135                 IBasicAgent::load(is);
+00136                 IAgentComposite::load(is);              
+00137         }               
+00138 
+00139         bool IAgent::runChildrenStepByStep()
+00140         {
+00141                 if(_Iter_Child != _AgentList.end())
+00142                 {
+00143                         IBasicAgent *c = *_Iter_Child;
+00144 
+00145                         if(c->runStep().ResultState == ProcessNotComplit.ResultState) return false;
+00146 
+00147                         if(c->getState().ResultState == processToKill)
+00148                         {
+00149                                 _Iter_Child ++;
+00150                                 removeChild(c);
+00151                         }
+00152                         else _Iter_Child++;
+00153 
+00154                         return false;
+00155 
+00156                 }
+00157 
+00158                 _Iter_Child = _AgentList.begin();               
+00159                 return true;
+00160         }
+00161 
+00162         void IAgent::runChildren()      // Se charge de l'activation des fils
+00163         {
+00164                 std::list<IBasicAgent *>::iterator i_agl = _AgentList.begin();          
+00165                 sint n = _SizeChild;
+00166 
+00167 #ifdef NL_DEBUG
+00168                 if(n != (sint)_AgentList.size())
+00169                                                                 throw;
+00170 #endif
+00171 
+00172                 while ( /*i_agl != _AgentList.end()*/n -- )
+00173                 {                                       
+00174                         IBasicAgent *c = *i_agl;
+00175 
+00176                         
+00177                         c->run();
+00178                         switch(c->getState().ResultState)
+00179                         {
+00180                         case processToKill:
+00181                                 {
+00182                                         i_agl ++;
+00183                                         removeChild(c);
+00184                                 }
+00185                                 break;
+00186                         case processPresKill:
+00187                                 {
+00188                                         i_agl ++;
+00189                                         c->incRef();
+00190                                         removeChild(c);
+00191                                         onKill(c);
+00192                                 }
+00193                                 break;
+00194                         default:
+00195                                 i_agl ++;
+00196                                 break;
+00197 
+00198                         };                      
+00199                 }
+00200         }               
+00201         
+00202         void IAgent::processMessages()
+00203         {
+00204                 IMailBox *mail = getMail();
+00205                 //const IMailBox::tListMessage &l = mail->getMesseageListe();
+00206                 sint n = mail->size();
+00207 
+00208                 while(/*l.begin() != l.end()*/ n --)
+00209                 {
+00210                         const IMessageBase &msg = getMail()->getMessage();
+00211 #ifdef NL_DEBUG
+00212         const char *msgBase = (const char *)msg.getType();
+00213         const char *classBase = (const char *)getType();
+00214 #endif
+00215                         try
+00216                         {
+00217                                 (void)IBasicAgent::run( msg );
+00218                                 mail->popMessage();
+00219                         }
+00220                         catch(NLAIE::IException &)
+00221                         {
+00222                                 // We send an Error message because the incoming message isn't processed.
+00223                                 IMessageBase *o = (IMessageBase *)msg.clone();
+00224                                 o->setMethodIndex(-1,-1);
+00225                                 o->setSender(this);
+00226                                 o->setPerformatif(IMessageBase::PError);
+00227                                 o->setReceiver((IObjectIA *)msg.getSender());
+00228                                 ((IObjectIA *)msg.getSender())->sendMessage(o);
+00229 
+00230                                 mail->popMessage();
+00231                         }               
+00232                 }
+00233         }
+00234 
+00235         /*std::string Shift="-";
+00236         sint kShift = 1;*/
+00237 
+00238         const IObjectIA::CProcessResult &IAgent::run()
+00239         {       
+00240                 /*nlinfo("%s<%4x> go to run %s with %d childs:",Shift.c_str(),this, (const char *)getType(),_AgentList.size());
+00241                 Shift += "\t";
+00242                 kShift++;*/
+00243 
+00244                 runChildren();          // Gestion des fils
+00245                 getMail()->run();       // Execution de la boite aux lettres
+00246 
+00247                 processMessages();      // Traitement de ses propres messages
+00248 
+00249                 if(haveActivity() && getState().ResultState == processIdle) runActivity();
+00250 
+00251                 /*kShift --;
+00252                 std::string chaine;
+00253                 sint i;
+00254                 for(i = 0; i < (sint)kShift; i ++)
+00255                 {
+00256                         chaine += Shift [i];                            
+00257                 }
+00258                 Shift = chaine;*/
+00259 
+00260 
+00261                 return getState();  
+00262         }
+00263 
+00264         const IObjectIA::CProcessResult &IAgent::runStep()
+00265         {
+00266                 if(runChildrenStepByStep())
+00267                 {
+00268                         getMail()->run();       // Execution de la boite aux lettres
+00269 
+00270                         processMessages();      // Traitement de ses propres messages
+00271 
+00272                         if(haveActivity() && getState().ResultState == processIdle) runActivity();
+00273                         return getState();
+00274                 }
+00275                 else 
+00276                         return IObjectIA::ProcessNotComplit;
+00277         }       
+00278 
+00279         const NLAIC::CIdentType &IAgent::getType() const
+00280         {               
+00281                 return *IdAgent;
+00282         }
+00283 
+00284 
+00287 
+00288         IBasicAgent::IBasicAgent(const IBasicAgent &a): IConnectIA(a),_Mail((IMailBox   *)a._Mail->clone())
+00289         {
+00290                 _Mail->setParent((const IWordNumRef *) *this);
+00291         }
+00292 
+00293 
+00294         IBasicAgent::IBasicAgent(const IWordNumRef *parent): IConnectIA(parent)
+00295         {
+00296                 _Mail = new tMailBoxLettre((const IWordNumRef *) *this);
+00297 
+00298         }               
+00299 
+00300         IBasicAgent::IBasicAgent(const IWordNumRef *parent,IMailBox     *m): IConnectIA(parent),_Mail(m)
+00301         {                       
+00302                 _Mail->setParent((const IWordNumRef *) *this);
+00303         }               
+00304 
+00305         IBasicAgent::~IBasicAgent()
+00306         {
+00307                 _Mail->setParent(NULL);
+00308                 _Mail->release();                       
+00309         }               
+00310 
+00311         const IObjectIA::CProcessResult &IBasicAgent::getState() const 
+00312         {
+00313                 return _RunState;
+00314         }
+00315 
+00316         void IBasicAgent::setState(TProcessStatement state, IObjectIA *result)
+00317         {
+00318                 _RunState.ResultState = state;
+00319                 _RunState.Result = result;
+00320         }
+00321 
+00322         IObjectIA::CProcessResult IBasicAgent::sendMessage(IMessageBase *msg)
+00323         {
+00324                 _Mail->addMessage(msg);
+00325                 return IObjectIA::ProcessRun;
+00326         }
+00327 
+00328         IObjectIA::CProcessResult IBasicAgent::sendMessage(IMessageBase *msg, IBasicAgent &receiver)
+00329         {
+00330                 receiver.getMail()->addMessage( msg );
+00331                 return IObjectIA::ProcessRun;
+00332         }
+00333 
+00334         IMailBox *IBasicAgent::getMail() const
+00335         {
+00336                 return _Mail;
+00337         }
+00338 
+00339         void IBasicAgent::save(NLMISC::IStream &os)
+00340         {                               
+00341                 IConnectIA::save(os);
+00342                 _Mail->save(os);                        
+00343         }
+00344 
+00345         void IBasicAgent::load(NLMISC::IStream &is)
+00346         {                       
+00347                 IConnectIA::load(is);
+00348                 _Mail->load(is);                                                
+00349                 NLAIC::CIdentTypeAlloc id;                      
+00350         }
+00351 
+00352         /*void IBasicAgent::addMsgGroup(IBasicMessageGroup &grp)
+00353         {
+00354                 getMail()->addGroup( grp );
+00355         }
+00356 
+00357         void IBasicAgent::removeMsgGroup(IBasicMessageGroup &grp)
+00358         {
+00359                 getMail()->removeGroup( grp );
+00360         }*/
+00361 
+00362         void IBasicAgent::onKill(IConnectIA *a)
+00363         {
+00364                 _Mail->onKill(a);
+00365         }
+00366 
+00367         IObjectIA *IBasicAgent::run(const IMessageBase &msg)
+00368         {
+00369                 IMessageBase *returnMsg = NULL;
+00370                 switch(msg.getPerformatif())
+00371                 {
+00372                 case IMessageBase::PUndefine:
+00373                         {
+00374                                 std::string text;
+00375                                 text = NLAIC::stringGetBuild("Function IObjectIA *IBasicAgent::run('%s') proccess an IMessageBase::PUndefine performatif",(const char *)msg.getType());
+00376                                 throw NLAIE::CExceptionNotImplemented(text.c_str());
+00377                         }
+00378                         break;          
+00379                 case IMessageBase::PExec:
+00380                 
+00381                         returnMsg = runExec(msg);
+00382                         if(msg.getContinuation() != NULL) 
+00383                         {
+00384                                 returnMsg->incRef();
+00385                                 ((IObjectIA *)msg.getContinuation())->sendMessage(returnMsg);
+00386                         }                               
+00387                         break;
+00388                 case IMessageBase::PAchieve:
+00389                         returnMsg = runAchieve(msg);
+00390                         if(msg.getContinuation() != NULL)
+00391                         {
+00392                                 returnMsg->incRef();
+00393                                 ((IObjectIA *)msg.getContinuation())->sendMessage(returnMsg);
+00394                         }
+00395                         break;
+00396                 case IMessageBase::PAsk:
+00397                         returnMsg = runAsk(msg);
+00398                         returnMsg->setPerformatif(IMessageBase::PTell);
+00399                         returnMsg->incRef();                    
+00400                         ((IObjectIA *)msg.getSender())->sendMessage(returnMsg);
+00401                         if(msg.getContinuation() != NULL)
+00402                         {                                       
+00403                                 returnMsg->incRef();
+00404                                 ((IObjectIA *)msg.getContinuation())->sendMessage(returnMsg);                           
+00405                         }                       
+00406                         break;
+00407                 case IMessageBase::PTell:                       
+00408                         returnMsg = runTell(msg);                       
+00409                         
+00410                         break;
+00411                 case IMessageBase::PBreak:
+00412                         returnMsg = runBreak(msg);
+00413                         break;
+00414                 case IMessageBase::PKill:
+00415                         returnMsg = runKill(msg);
+00416                         break;
+00417                 case IMessageBase::PError:
+00418                         returnMsg = runError(msg);
+00419                         break;
+00420 
+00421                 case IMessageBase::PEven:
+00422                         returnMsg = runEven(msg);
+00423                         ((IMessageBase &)msg).setDispatch();
+00424                         break;
+00425                 default: break;
+00426                 }
+00427                 
+00428                 if(returnMsg) returnMsg->release();
+00429                 return NULL;
+00430         }
+00431         
+00432 
+00433         const static sint32 _GetMailer = 0;
+00434         const static sint32 _Father = 1;
+00435         const static sint32 _RunTel = 2;
+00436         const static sint32 _RunAsk = 3;
+00437         const static sint32 _GetNumId = 4;      
+00438         const static sint32 _LastM = 5;
+00439 
+00440         IBasicAgent::CMethodCall IBasicAgent::_Method[] = 
+00441         {
+00442                 IBasicAgent::CMethodCall(_MAILER_,_GetMailer),
+00443                 IBasicAgent::CMethodCall(_FATHER_,_Father),
+00444                 IBasicAgent::CMethodCall(_RUNTEL_,_RunTel),
+00445                 IBasicAgent::CMethodCall(_RUNASK_,_RunAsk),
+00446                 IBasicAgent::CMethodCall(_GETNUMID_,_GetNumId)
+00447         };
+00448         
+00449 
+00450         sint32 IBasicAgent::getMethodIndexSize() const
+00451         {
+00452                 return IObjectIA::getMethodIndexSize() + _LastM;
+00453         }       
+00454 
+00455         tQueue IBasicAgent::isMember(const IVarName *className,const IVarName *methodName,const IObjectIA &p) const
+00456         {                       
+00457                 if(className == NULL)
+00458                 {
+00459                         tQueue a;
+00460                         for(int i = 0; i < _LastM; i++)
+00461                         {
+00462                                 if(*methodName == IBasicAgent::_Method[i].MethodName)
+00463                                 {       
+00464                                         CObjectType *c;
+00465                                         if(i == _RunTel || i == _RunAsk)
+00466                                         {
+00467                                                 static NLAISCRIPT::CParam paramMsg(1,new NLAISCRIPT::COperandSimple (new NLAIC::CIdentType(NLAISCRIPT::CMsgNotifyParentClass::IdMsgNotifyParentClass)));
+00468 
+00469                                                 if(paramMsg.eval((NLAISCRIPT::CParam &)p) < 0.0) continue;
+00470                                                 c = new CObjectType(new NLAIC::CIdentType(NLAISCRIPT::CMessageClass::IdMessageClass));
+00471                                         }
+00472                                         else
+00473                                         if (i == _GetNumId)
+00474                                         {
+00475                                                 c = new CObjectType(new NLAIC::CIdentType(CStringType::IdStringType));
+00476                                         }
+00477                                         else
+00478                                         {
+00479                                                 c = new CObjectType(new NLAIC::CIdentType(CLocalAgentMail::LocalAgentMail));
+00480                                         }
+00481                                         a.push(CIdMethod(IBasicAgent::_Method[i].Index + IObjectIA::getMethodIndexSize(),0.0,NULL,c));                                  
+00482                                         break;
+00483                                 }
+00484                         }
+00485 
+00486                         if(a.size()) return a;
+00487                         else return IConnectIA::isMember(className,methodName,p);
+00488                 }
+00489                 return IConnectIA::isMember(className,methodName,p);
+00490         }
+00491 
+00492         IObjectIA::CProcessResult IBasicAgent::runMethodeMember(sint32 h, sint32 index,IObjectIA *p)
+00493         {
+00494                 return IConnectIA::runMethodeMember(h,index,p);
+00495         }
+00496 
+00497         IObjectIA::CProcessResult IBasicAgent::runMethodeMember(sint32 index,IObjectIA *p)
+00498         {
+00499                 IBaseGroupType *param = (IBaseGroupType *)p;
+00500 
+00501                 switch(index - IObjectIA::getMethodIndexSize())
+00502                 {
+00503                 case _GetMailer:
+00504                         {
+00505                                 IObjectIA::CProcessResult a;                            
+00506                                 a.Result = new CLocalAgentMail(this);                           
+00507                                 return a;
+00508                         }                       
+00509                         break;
+00510 
+00511                 case _Father:
+00512                         {
+00513                                 IObjectIA::CProcessResult a;
+00514                                 IRefrence *father = getParent();
+00515                                 if ( father )
+00516                                         a.Result = new CLocalAgentMail( (IBasicAgent *) father );                               
+00517                                 else
+00518                                 {
+00519                                         a.Result = &DigitalType::NullOperator;
+00520                                         a.Result->incRef();
+00521                                 }
+00522                                 return a;
+00523                         }       
+00524                         break;
+00525 
+00526                 case _RunAsk:
+00527                 case _RunTel:
+00528                         {
+00529                                 IObjectIA::CProcessResult a;
+00530                                 a.Result = run((const IMessageBase &)*param->get());
+00531                                 return a;
+00532                         }
+00533                         break;
+00534 
+00535                 case _GetNumId:         
+00536                         {                               
+00537                                 IObjectIA::CProcessResult a;
+00538                                 std::string t;
+00539                                 ((const IWordNumRef &)*this).getNumIdent().getDebugString(t);
+00540                                 a.Result = new CStringType(CStringVarName(t.c_str()));
+00541                                 return a;
+00542                         }
+00543                         break;
+00544 
+00545                 }
+00546                 return IConnectIA::runMethodeMember(index,p);
+00547         }
+00548 
+00549         IMessageBase *IBasicAgent::runAsk(const IMessageBase &m)
+00550         {
+00551                 if(NLAISCRIPT::CMsgNotifyParentClass::IdMsgNotifyParentClass == m.getType())
+00552                 {
+00553                         if(getParent() != NULL)
+00554                         {
+00555                                 CNotifyParentScript *msg = new CNotifyParentScript();
+00556                                 return msg;
+00557                         }
+00558                         else
+00559                         {
+00560                                 CNotifyParentScript *msg = new CNotifyParentScript((IBasicAgent *)getParent());
+00561                                 return msg;
+00562                         }
+00563                 }
+00564                 else
+00565                 {
+00566                         std::string debugString;
+00567                         std::string text;
+00568                         getDebugString(debugString);
+00569                         text += NLAIC::stringGetBuild("runAsk(%s) note implementaited for the '%s' interface for the instence '%s'",(const char *)m.getType(),(const char *)getType(),debugString.c_str());
+00570                         throw NLAIE::CExceptionNotImplemented(text.c_str());
+00571                         return NULL;
+00572                 }               
+00573         }
+00574                 
+00575         IMessageBase *IBasicAgent::runTell(const IMessageBase &m)
+00576         {
+00577                 if(NLAISCRIPT::CMsgNotifyParentClass::IdMsgNotifyParentClass == m.getType())
+00578                 {
+00579                         /*const INombreDefine *n = (const INombreDefine *)m.getFront();
+00580                         if(n->getNumber() != 0.0)
+00581                         {
+00582                                 const CLocalAgentMail *parent = (const CLocalAgentMail *)m.get();
+00583                         }*/
+00584                         return (IMessageBase *)m.clone();                       
+00585                 }
+00586                 else
+00587                 {
+00588 /*                      std::string debugString;
+00589                         std::string text;
+00590                         getDebugString(debugString);
+00591                         text += NLAIC::stringGetBuild("runTell(%s) note implementaited for the '%s' interface for the instence '%s'",(const char *)m.getType(),(const char *)getType(),debugString.c_str());
+00592                         throw NLAIE::CExceptionNotImplemented(text.c_str()); */
+00593                         return NULL;
+00594                 }
+00595         }       
+00596 }
+
agents.cpp
