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/agent_script.h"
+00026 
+00027 namespace NLAIAGENT
+00028 {
+00029 
+00030         IMailBox::IMailBox(const IWordNumRef *parent):IConnectIA(parent)
+00031         {
+00032         }
+00033 
+00034         IMailBox::IMailBox(const IMailBox &c) : IConnectIA(c)
+00035         {
+00036         }
+00037 
+00038         IMailBox::IMailBox(NLMISC::IStream &is):IConnectIA(is)
+00039         {                       
+00040         }       
+00041 
+00042         IMailBox::~IMailBox()
+00043         {
+00044         }
+00045 
+00046         CSimpleLocalMailBox::CSimpleLocalMailBox(const IWordNumRef *parent) : IMailBox(parent), _Size(0)
+00047         {
+00048         }
+00049 
+00050         CSimpleLocalMailBox::CSimpleLocalMailBox(NLMISC::IStream &is) : IMailBox(is), _Size(0)
+00051         {
+00052                 load(is);
+00053         }
+00054 
+00055 
+00056         CSimpleLocalMailBox::CSimpleLocalMailBox(const CSimpleLocalMailBox &a) : IMailBox(a), _Size(0)
+00057         {                                       
+00058                 tListMessage::const_reverse_iterator i = a._ListMessage.rbegin();
+00059                 while(i != a._ListMessage.rend())
+00060                 {
+00061                         _ListMessage.push_back(*i++);
+00062                         ((IMessageBase *)_ListMessage.back())->incRef();
+00063                         _Size ++;
+00064                 }
+00065                 _RunState = a._RunState;
+00066         }
+00067         
+00068         CSimpleLocalMailBox::~CSimpleLocalMailBox()
+00069         {                       
+00070                 while(_ListMessage.begin() != _ListMessage.end())
+00071                 {
+00072                         IMessageBase *m = (IMessageBase *)_ListMessage.back();
+00073                         m->release();
+00074                         _ListMessage.pop_back();                                
+00075                 }
+00076         }
+00077 
+00078         void CSimpleLocalMailBox::addMessage(IMessageBase *msg)
+00079         {
+00080                 _ListMessage.push_front( msg );
+00081                 _Size ++;
+00082         }
+00083 
+00084         void CSimpleLocalMailBox::addMailBox(IMailBox *)
+00085         {
+00086         }
+00087 
+00088         void CSimpleLocalMailBox::removeMailBox(IMailBox *)
+00089         {
+00090         }
+00091 
+00092         const IMessageBase &CSimpleLocalMailBox::getMessage()
+00093         {
+00094                 return *_ListMessage.back();
+00095         }
+00096         
+00097         void CSimpleLocalMailBox::popMessage()
+00098         {
+00099                 ((IMessageBase *)_ListMessage.back())->release();               
+00100                 _ListMessage.pop_back();
+00101                 _Size --;
+00102         }
+00103 
+00104         sint32 CSimpleLocalMailBox::getMessageCount() const
+00105         {
+00106                 return _ListMessage.size();
+00107         }
+00108         bool CSimpleLocalMailBox::isEmpty() const
+00109         {
+00110                 return _Size == 0;//_ListMessage.begin() == _ListMessage.end();
+00111         }
+00112 
+00113         std::list<const IMessageBase *> *CSimpleLocalMailBox::pumpMessages(/*IBasicMessageGroup &*/) const
+00114         {
+00115                 std::list<const IMessageBase *> *result = new std::list<const IMessageBase *>;
+00116 
+00117                 std::list<const IMessageBase *>::const_iterator i = _ListMessage.begin();
+00118                 while(i != _ListMessage.end() )
+00119                 {
+00120                         result->push_back( *i++ );
+00121                 }
+00122                 return result;
+00123         }
+00124 
+00125         /*void CSimpleLocalMailBox::addGroup(IBasicMessageGroup &)
+00126         {
+00127 
+00128         }
+00129 
+00130         void CSimpleLocalMailBox::removeGroup(IBasicMessageGroup &)
+00131         {
+00132 
+00133         }
+00134 
+00135         std::list<IBasicMessageGroup *> &CSimpleLocalMailBox::getGroups()
+00136         {
+00137                 return _Msg_grps;
+00138         }*/
+00139 
+00140         const IObjectIA::CProcessResult &CSimpleLocalMailBox::getState() const 
+00141         {
+00142                 return _RunState;
+00143         }
+00144 
+00145         void CSimpleLocalMailBox::setState(TProcessStatement state, IObjectIA *result)
+00146         {
+00147                 _RunState.ResultState = state;
+00148                 _RunState.Result = result;
+00149         }
+00150 
+00151         const IObjectIA::CProcessResult &CSimpleLocalMailBox::run()
+00152         {
+00153                 return IObjectIA::ProcessRun;
+00154         }
+00155 
+00156         bool CSimpleLocalMailBox::isEqual(const IBasicObjectIA &a) const
+00157         {
+00158                 const IMailBox &m = (const IMailBox &)a;
+00159                 return (const IWordNumRef &)m == (const IWordNumRef &)*this;
+00160         }
+00161 
+00162         const NLAIC::IBasicType *CSimpleLocalMailBox::clone() const
+00163         {
+00164                 NLAIC::IBasicType *a = new CSimpleLocalMailBox(*this);
+00165                 return a;
+00166         }
+00167 
+00168         const NLAIC::IBasicType *CSimpleLocalMailBox::newInstance() const
+00169         {                               
+00170                 NLAIC::IBasicType *a;
+00171                 if(getParent() != NULL) 
+00172                         a = new CSimpleLocalMailBox((const IWordNumRef *) getParent());
+00173                 else 
+00174                         a = new CSimpleLocalMailBox((const IWordNumRef *) NULL);
+00175                 return a;
+00176         }
+00177 
+00178         const NLAIC::CIdentType &CSimpleLocalMailBox::getType() const
+00179         {
+00180                 return IdSimpleLocalMailBox;
+00181         }
+00182 
+00183         void CSimpleLocalMailBox::getDebugString(std::string &t) const
+00184         {
+00185                 t += "class CSimpleLocalMailBox";
+00186         }
+00187 
+00188         void CSimpleLocalMailBox::save(NLMISC::IStream &os)
+00189         {                               
+00190                 IConnectIA::save(os);
+00191                 sint32 size = _ListMessage.size();
+00192                 os.serial( size );
+00193 
+00194                 tListMessage::const_iterator i = _ListMessage.begin();
+00195                 while(i != _ListMessage.end())
+00196                 {
+00197                         IMessageBase &m = (IMessageBase &)*(*i);
+00198                         os.serial( (NLAIC::CIdentType &) m.getType() );
+00199                         //os.serial( (IMessageBase &) m );
+00200                         m.save(os);
+00201                 }
+00202                 
+00203         }
+00204 
+00205         void CSimpleLocalMailBox::load(NLMISC::IStream &is)
+00206         {                       
+00207                 IConnectIA::load(is);
+00208                 while(_ListMessage.size())
+00209                 {
+00210                         ((IMessageBase *)_ListMessage.back())->release();
+00211                         _ListMessage.pop_back();                                
+00212                 }
+00213                 _Size = 0;
+00214 
+00215                 NLAIC::CIdentTypeAlloc id;
+00216                 sint32 i;
+00217                 is.serial(i);                           
+00218                 if(i)
+00219                 {
+00220                         while(i --)
+00221                         {
+00222                                 is.serial(id);
+00223                                 IMessageBase *m = (IMessageBase *)id.allocClass();
+00224                                 is.serial( *m );
+00225                                 _ListMessage.push_back(m);
+00226                                 _Size ++;
+00227                         }
+00228                 }
+00229         }
+00230 
+00231         void CSimpleLocalMailBox::onKill(IConnectIA *)
+00232         {                                                       
+00233         }
+00234 
+00235         IObjectIA::CProcessResult CSimpleLocalMailBox::sendMessage(IMessageBase *m)
+00236         {
+00237                 m->release();
+00238                 return IObjectIA::ProcessRun;
+00239         }
+00240 
+00241         IConnectIA &CSimpleLocalMailBox::getConnection(IConnectIA &r)
+00242         {                                                               
+00243                 addInConnectedList(&r);                         
+00244                 return *this;
+00245         }                       
+00246 
+00247         CLocalMailBox::CLocalMailBox (const IWordNumRef *parent):IMailBox(parent),_Size(0)
+00248         {
+00249         }
+00250 
+00251         CLocalMailBox::CLocalMailBox(NLMISC::IStream &is):IMailBox(is),_Size(0)
+00252         {
+00253                 load(is);
+00254         }
+00255 
+00256 
+00257         CLocalMailBox::CLocalMailBox (const CLocalMailBox &A):IMailBox(A),_RunState(A._RunState),_Size(0)
+00258         {                                               
+00259                 /*tListMailBox::const_reverse_iterator i = A._ListMailBox.rbegin();
+00260                 while(i != A._ListMailBox.rend())
+00261                 {
+00262                         connect(*i);
+00263                         _ListMailBox.push_back(*i++);
+00264                 }*/     
+00265         }
+00266 
+00267         CLocalMailBox::~CLocalMailBox()
+00268         {
+00269                 while(_ListMessageIn.begin() != _ListMessageIn.end())
+00270                 {
+00271                         IMessageBase *msg = (IMessageBase *)_ListMessageIn.back();
+00272 #ifdef NL_DEBUG
+00273                         const char *mname = (const char *)msg->getType();
+00274 #endif
+00275                         msg->release();
+00276                         _ListMessageIn.pop_back();
+00277                 }
+00278 
+00279                 while(_ListSharedMessage.begin() != _ListSharedMessage.end())
+00280                 {
+00281                         IMessageBase *msg = (IMessageBase *)_ListSharedMessage.back();
+00282                         msg->release();
+00283                         _ListSharedMessage.pop_back();
+00284                 }
+00285 
+00286         }
+00287                                 
+00288         void CLocalMailBox::shareMessage()
+00289         {
+00290                 IMessageBase *msg = (IMessageBase *)_ListMessageIn.back();
+00291                 msg->incRef();
+00292                 _ListSharedMessage.push_back(msg);
+00293         }
+00294 
+00295         const IMessageBase &CLocalMailBox::getMessage()
+00296         {                               
+00297                 return *_ListMessageIn.back();
+00298         }
+00299 
+00300         void CLocalMailBox::popMessage()
+00301         {       
+00302 
+00303                 /*IMessageBase *msg = (IMessageBase *)_ListMessageIn.back();
+00304                 _ListMessageIn.pop_back();
+00305                 if(msg->getDispatch())
+00306                 {
+00307                         _ListSharedMessage.push_back(msg);
+00308                 }
+00309                 else
+00310                 {                       
+00311                         msg->release();
+00312                 }*/
+00313                 ((IMessageBase *)_ListMessageIn.back())->release();
+00314                 _ListMessageIn.pop_back();
+00315                 _Size --;
+00316         }
+00317 
+00318         sint32 CLocalMailBox::getMessageCount() const
+00319         {
+00320                 return _Size;
+00321         }
+00322 
+00323         bool CLocalMailBox::isEmpty() const
+00324         {
+00325                 return _Size == 0;//_ListMessageIn.begin() == _ListMessageIn.end();
+00326         }
+00327         
+00328         /*void CLocalMailBox::sendMessage(const IBasicAgent &,const IBaseGroupType &)
+00329         {                                       
+00330         }*/
+00331 
+00332         IObjectIA::CProcessResult CLocalMailBox::sendMessage(IMessageBase *m)
+00333         {
+00334                 m->release();
+00335                 //_listMessageOut.push_back((const IMessageBase *)msg.clone());
+00336                 return IObjectIA::ProcessRun;
+00337         }
+00338 
+00339         void CLocalMailBox::addMessage(IMessageBase *msg)
+00340         {
+00341                 _ListMessageIn.push_front(msg);
+00342                 _Size ++;
+00343         }
+00344         
+00345         // Ajoute une boite aux lettre dans la liste des boites aux lettres "source" (les bals � consulter).
+00346         void CLocalMailBox::addMailBox(IMailBox *mail)
+00347         {
+00348                 connect( mail );
+00349                 _ListMailBox.push_back((IMailBox *)mail);
+00350 
+00351                 /*std::list<IBasicMessageGroup *>::const_iterator it_grp = mail->getGroups().begin();
+00352                 while ( it_grp != mail->getGroups().end() )
+00353                 {
+00354                         _Msg_grps.push_back( *it_grp );
+00355                         it_grp++;
+00356                 }*/
+00357 
+00358         }
+00359 
+00360         // Supprime une boite aux lettre dans la liste des boites aux lettres "source" (les bals � consulter).
+00361         void CLocalMailBox::removeMailBox(IMailBox *mail)
+00362         {                               
+00363                 eraseFromList<IMailBox *>(&_ListMailBox,mail);
+00364                 removeConnection(mail);
+00365         }
+00366 
+00367         void CLocalMailBox::setName(const IVarName &)
+00368         {                               
+00369         }
+00370 
+00371         const NLAIC::IBasicType *CLocalMailBox::clone() const
+00372         {
+00373                 NLAIC::IBasicType *a = new CLocalMailBox(*this);
+00374                 return a;
+00375         }
+00376 
+00377         const NLAIC::IBasicType *CLocalMailBox::newInstance() const
+00378         {                               
+00379                 NLAIC::IBasicType *a;
+00380                 if(getParent() != NULL) 
+00381                         a = new CLocalMailBox((const IWordNumRef *)getParent());
+00382                 else 
+00383                         a = new CLocalMailBox((const IWordNumRef *)NULL);
+00384                 return a;
+00385         }
+00386 
+00387         const NLAIC::CIdentType &CLocalMailBox::getType() const
+00388         {
+00389                 return IdLocalMailBox;
+00390         }
+00391 
+00392         void CLocalMailBox::onKill(IConnectIA *a)
+00393         {                               
+00394                 eraseFromList<IMailBox *>(&_ListMailBox,(IMailBox *)a);
+00395 
+00396                 tListMessageIter msgItr = _ListMessageIn.begin();
+00397                 while(msgItr != _ListMessageIn.end())
+00398                 {
+00399                         IMessageBase *msg = (IMessageBase *)*msgItr;
+00400 
+00401                         if(msg->getSender() == a || msg->getContinuation() == a)
+00402                         {
+00403                                 tListMessageIter iTmp = msgItr++;
+00404                                 _ListMessageIn.erase(iTmp);
+00405                                 msg->release();
+00406                                 _Size --;
+00407                         }
+00408                         else msgItr++;                  
+00409                 }
+00410 
+00411         }
+00412         
+00413         bool CLocalMailBox::isEqual(const IBasicObjectIA &a) const
+00414         {
+00415                 const IMailBox &m = (const IMailBox &)a;
+00416                 return (const IWordNumRef &)m == (const IWordNumRef &)*this;
+00417         }
+00418 
+00419         void CLocalMailBox::save(NLMISC::IStream &os)
+00420         {       
+00421                 IMailBox::save(os);
+00422                 sint32 size = _ListMailBox.size();
+00423                 os.serial( size );
+00424                 tListMailBoxCstIter k = _ListMailBox.begin();
+00425                 while(k != _ListMailBox.end())
+00426                 {
+00427                         IMailBox *mail = *k++;                                  
+00428                         ((IWordNumRef *)(const NLAIAGENT::IWordNumRef *)*mail)->save(os);
+00429                 }
+00430 
+00431                 size = _ListMessageIn.size();
+00432                 os.serial( size );
+00433                 tListMessageIter msgItr = _ListMessageIn.begin();
+00434                 while(msgItr != _ListMessageIn.end())
+00435                 {
+00436                         IMessageBase *msg = (IMessageBase *)*msgItr++;
+00437                         os.serial( (NLAIC::CIdentType &) (msg->getType()) );
+00438                         msg->save(os);
+00439                 }
+00440 
+00441                 size = _ListSharedMessage.size();
+00442                 os.serial( size );
+00443                 msgItr = _ListSharedMessage.begin();
+00444                 while(msgItr != _ListSharedMessage.end())
+00445                 {
+00446                         IMessageBase *msg = (IMessageBase *)*msgItr++;
+00447                         os.serial( (NLAIC::CIdentType &) (msg->getType()) );
+00448                         msg->save(os);
+00449                 }
+00450                 //_ListMessageIn.save(os);
+00451         }
+00452 
+00453         void CLocalMailBox::load(NLMISC::IStream &is)
+00454         {                       
+00455                 IMailBox::load(is);
+00456                 sint32 i;                               
+00457                 NLAIC::CIdentTypeAlloc id;                      
+00458                 is.serial(i);
+00459                 _Size = 0;
+00460                 if(i)
+00461                 {
+00462                         while(i --)
+00463                         {
+00464                                 is.serial(id);
+00465                                 IWordNumRef *num = (IWordNumRef *)id.allocClass();
+00466                                 num->load(is);
+00467                                 _ListMailBox.push_back((IMailBox *)((const IRefrence *)*num));
+00468                                 _Size ++;
+00469                                 delete num;
+00470                         }
+00471                 }
+00472 
+00473                 //_ListMessageIn.load(is);
+00474         }                                       
+00475 
+00476         const IObjectIA::CProcessResult &CLocalMailBox::getState() const 
+00477         {
+00478                 return _RunState;
+00479         }
+00480 
+00481         void CLocalMailBox::setState(TProcessStatement state, IObjectIA *result)
+00482         {
+00483                 _RunState.ResultState = state;
+00484                 _RunState.Result = result;
+00485         }
+00486 
+00487         std::list<const IMessageBase *> *CLocalMailBox::pumpMessages(/*IBasicMessageGroup &grp*/) const
+00488         {
+00489                 //return _ListMessageIn.pumpMessages( grp );
+00490                 if(_ListSharedMessage.begin() != _ListSharedMessage.end())
+00491                 {
+00492                         std::list<const IMessageBase *> *l = new tListMessage;
+00493                         tListMessageCstIter msgItr = _ListSharedMessage.begin();
+00494                         while(msgItr != _ListSharedMessage.end())
+00495                         {       
+00496                                 const IMessageBase *msg = *msgItr++;
+00497                                 l->push_back((const IMessageBase *)msg->clone());                                                               
+00498                         }
+00499                         return l;
+00500                 }
+00501                 return NULL;
+00502         }
+00503 
+00504         const IObjectIA::CProcessResult &CLocalMailBox::run()
+00505         {               
+00506 
+00507                 /*while(_ListSharedMessage.begin() != _ListSharedMessage.end())
+00508                 {
+00509                         _ListSharedMessage.back()->release();                   
+00510                         _ListSharedMessage.pop_back();
+00511                 }
+00512                 tListMailBoxIter j;
+00513                 fillMailBox();*/
+00514                 return getState();
+00515         }
+00516 
+00517         void CLocalMailBox::getDebugString(std::string &t) const
+00518         {
+00519                 t += "class CLocalMailBox parent";
+00520                 /*if(getParent() != NULL)
+00521                 {
+00522                         const IObjectIA *o = getParent();
+00523                         t += (const char *)o->getType();
+00524                         t += ">";
+00525                 }
+00526                 else
+00527                         t += "NULL>";*/
+00528 
+00529         }
+00530 
+00531         void CLocalMailBox::fillMailBox()
+00532         {               
+00533                 tListMailBoxIter i_mbox = _ListMailBox.begin();
+00534 
+00535 #ifdef NL_DEBUG
+00536                 int s = _ListMailBox.size();
+00537 #endif
+00538 
+00539                 while ( i_mbox != _ListMailBox.end() )
+00540                 {
+00541                         IMailBox *box = (*i_mbox);
+00542                         std::list<const IMessageBase *> *msg_lst = box->pumpMessages();
+00543                         if ( msg_lst != NULL)
+00544                         {
+00545                                 while ( msg_lst->begin() != msg_lst->end())
+00546                                 {
+00547                                         IMessageBase *m = (IMessageBase *) msg_lst->front();
+00548                                         m->incRef();
+00549                                         _ListMessageIn.push_back(m);
+00550                                         m->release();
+00551                                         msg_lst->pop_front();
+00552                                 }
+00553                                 delete msg_lst;
+00554                         }
+00555                         i_mbox++;
+00556                 }
+00557         }
+00558 
+00559 
+00560         CScriptMailBox::CScriptMailBox(const IWordNumRef *parent) : CSimpleLocalMailBox(parent)
+00561         {
+00562         }
+00563 
+00564         CScriptMailBox::CScriptMailBox(NLMISC::IStream &is) : CSimpleLocalMailBox(is)
+00565         {
+00566                 load(is);
+00567         }
+00568 
+00569         CScriptMailBox::CScriptMailBox(const CScriptMailBox &a) : CSimpleLocalMailBox(a)
+00570         {                                       
+00571                 tListMessage::const_reverse_iterator i = a._ListMessage.rbegin();
+00572                 while(i != a._ListMessage.rend())
+00573                 {
+00574                         _ListMessage.push_back(*i++);
+00575                         ((IMessageBase *)_ListMessage.back())->incRef();
+00576                 }
+00577                 _RunState = a._RunState;
+00578         }
+00579         
+00580         CScriptMailBox::~CScriptMailBox()
+00581         {                       
+00582                 while(_ListMessage.begin() != _ListMessage.end())
+00583                 {
+00584                         IMessageBase *m = (IMessageBase *)_ListMessage.back();
+00585                         m->release();
+00586                         _ListMessage.pop_back();                                
+00587                 }
+00588         }
+00589 
+00590         const IObjectIA::CProcessResult &CScriptMailBox::run()
+00591         {
+00592                 // Get messages from the father's mailbox
+00593                 fillMailBox();
+00594                 return IObjectIA::ProcessRun;
+00595         }
+00596 
+00598         void CScriptMailBox::fillMailBox()
+00599         {               
+00600         }
+00601 
+00602         void CScriptMailBox::setIndex(sint32 i)
+00603         {
+00604                 _CIndex = i;
+00605         }
+00606 
+00607         sint32 CScriptMailBox::getIndex()
+00608         {
+00609                 return _CIndex;
+00610         }
+00611 
+00612         const IMessageBase *CScriptMailBox::translateMsg(const IMessageBase *msg)
+00613         {
+00614                 CAgentScript *father = (CAgentScript *) getParent()->getParent();
+00615 
+00616                 sint32 index = father->getChildMessageIndex( msg, _CIndex );
+00617 
+00618                 if ( index != -1 )
+00619                 {
+00620                         IMessageBase *translated_msg = (IMessageBase *) msg->clone();
+00621                         translated_msg->setMethodIndex( 0, index + ( (CAgentScript *) getParent())->getBaseMethodCount() );
+00622                         return translated_msg;
+00623                 }
+00624                 return NULL;
+00625         }
+00626 
+00627         const NLAIC::IBasicType *CScriptMailBox::clone() const
+00628         {
+00629                 NLAIC::IBasicType *a = new CScriptMailBox(*this);
+00630                 return a;
+00631         }
+00632 
+00633         const NLAIC::IBasicType *CScriptMailBox::newInstance() const
+00634         {
+00635                 NLAIC::IBasicType *a;
+00636                 if(getParent() != NULL)
+00637                         a = new CScriptMailBox((const IWordNumRef *)getParent());
+00638                 else
+00639                         a = new CScriptMailBox((const IWordNumRef *)NULL);
+00640                 return a;
+00641         }
+00642 
+00643         const NLAIC::CIdentType &CScriptMailBox::getType() const
+00644         {
+00645                 return IdScriptMailBox;
+00646         }
+00647 }
+
mailbox.cpp
