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_local_mailer.h"
+00026 #include "nel/ai/agent/agent_proxy_mailer.h"
+00027 #include "nel/ai/logic/boolval.h"
+00028 #include "nel/ai/agent/object_type.h"
+00029 #include "nel/ai/agent/agent_method_def.h"
+00030 #include "nel/ai/agent/agent_digital.h" 
+00031 
+00032 namespace NLAIAGENT
+00033 {
+00034 
+00035         const NLAIC::IBasicType *CMessageGroup::clone() const 
+00036         {
+00037                 NLAIC::IBasicType *x = new CMessageGroup( *this );
+00038 
+00039 #ifdef NL_DEBUG
+00040         static sint kaka = 0;
+00041 #endif
+00042                 return x;
+00043         }
+00044 
+00045         const NLAIC::IBasicType *CMessageGroup::newInstance() const 
+00046         {
+00047                 NLAIC::IBasicType *x = new CMessageGroup( *this );
+00048                 return x;
+00049         }
+00050 
+00051 
+00052         const static sint32 _TSender = 0;
+00053         const static sint32 _TReceiver = 1;
+00054         const static sint32 _TXchgReceiverIsSender = 2;
+00055         const static sint32 _TContinuation = 3; 
+00056         const static sint32 _TSetContinuation = 4;
+00057         const static sint32 _TSetSender = 5;
+00058         const static sint32 _TInitProtocol = 6; 
+00059         const static sint32 _TProtcetSender = 7;                
+00060         const static sint32 _MLastM = 8;
+00061 
+00062         IMessageBase::CMethodCall IMessageBase::_Method[] = 
+00063         {
+00064                 IMessageBase::CMethodCall(_SENDER_,_TSender),           
+00065                 IMessageBase::CMethodCall(_RECEIVER_,_TReceiver),               
+00066                 IMessageBase::CMethodCall(_CONTINUATION_,_TContinuation),
+00067                 IMessageBase::CMethodCall(_SETCONTINUATION_,_TSetContinuation),
+00068                 IMessageBase::CMethodCall("XChangeReceiverSender",_TXchgReceiverIsSender),
+00069                 IMessageBase::CMethodCall("ProtcetSender",_TProtcetSender),
+00070                 IMessageBase::CMethodCall("InitProtocol",_TInitProtocol),
+00071                 IMessageBase::CMethodCall("SetSender",_TSetSender)              
+00072                 
+00073         };
+00074 
+00075         /*IntegerType IMessageBase::IdExec = IntegerType(IMessageBase::PExec);
+00076         IntegerType IMessageBase::IdAchieve = IntegerType(IMessageBase::PAchieve);
+00077         IntegerType IMessageBase::IdAsk = IntegerType(IMessageBase::PAsk);
+00078         IntegerType IMessageBase::IdBreak = IntegerType(IMessageBase::PBreak);
+00079         IntegerType IMessageBase::IdTell = IntegerType(IMessageBase::PTell);
+00080         IntegerType IMessageBase::IdKill = IntegerType(IMessageBase::PKill);*/
+00081 
+00082         IMessageBase::IMessageBase():IListBasicManager(),_Sender(NULL),_MsgGroup(NULL)
+00083         {
+00084                 _ReservedMethodIndexVar = -1;
+00085                 _ReservedHeritanceIndexVar = 0;
+00086                 _Receiver = NULL;
+00087                 _Continuation = NULL;
+00088                 _Performatif = PUndefine;
+00089                 _comeFromC_PLUS = true;
+00090                 _Dispatch = false;
+00091                 _ProtectSender = false;
+00092                 _SenderIsVolatile = false;
+00093                 _ReceiverIsVolatile = false;            
+00094                 _ContinuationIsVolatile = false;
+00095         }
+00096         IMessageBase::IMessageBase(IObjectIA *sender,IBaseGroupType *g):IListBasicManager(g),_Sender(sender),_MsgGroup(NULL)
+00097         {
+00098                 _ReservedMethodIndexVar = -1;
+00099                 _ReservedHeritanceIndexVar = 0;
+00100                 _Receiver = NULL;
+00101                 _Continuation = NULL;
+00102                 _Performatif = PUndefine;
+00103                 _comeFromC_PLUS = true;
+00104                 _Dispatch = false;
+00105                 _ProtectSender = false;
+00106                 _SenderIsVolatile = false;
+00107                 _ReceiverIsVolatile = false;            
+00108                 _ContinuationIsVolatile = false;
+00109         }
+00110 
+00111         IMessageBase::IMessageBase(IObjectIA *sender, IBasicMessageGroup &msg_group,IBaseGroupType *g):
+00112                                                         IListBasicManager(g),_Sender(sender),_MsgGroup((IBasicMessageGroup *)msg_group.clone())
+00113         {
+00114                 _ReservedMethodIndexVar = -1;
+00115                 _ReservedHeritanceIndexVar = 0;
+00116                 _Receiver = NULL;
+00117                 _Continuation = NULL;
+00118                 _Performatif = PUndefine;
+00119                 _comeFromC_PLUS = true;
+00120                 _Dispatch = false;
+00121                 _ProtectSender = false;
+00122                 _SenderIsVolatile = false;
+00123                 _ReceiverIsVolatile = false;            
+00124                 _ContinuationIsVolatile = false;
+00125         }
+00126 
+00127         IMessageBase::IMessageBase(const IMessageBase &m):IListBasicManager(m._List != NULL ? (IBaseGroupType *)m._List->clone(): NULL)
+00128         {
+00129                 _Sender = m._Sender;
+00130                 _SenderIsVolatile = m._SenderIsVolatile;
+00131                 if(_SenderIsVolatile && _Sender != NULL) _Sender->incRef();
+00132                 _Receiver = m._Receiver;
+00133                 _ReceiverIsVolatile = m._ReceiverIsVolatile;
+00134                 if(_ReceiverIsVolatile && _Receiver != NULL) _Receiver->incRef();
+00135                 _Continuation = m._Continuation;
+00136                 _ContinuationIsVolatile = m._ContinuationIsVolatile;
+00137                 if(_ContinuationIsVolatile && _Continuation != NULL) _Continuation->incRef();
+00138 
+00139                 if(m._MsgGroup) _MsgGroup = (IBasicMessageGroup *)m._MsgGroup->clone();
+00140                 else _MsgGroup = NULL;
+00141                 //_Message = (IBaseGroupType *)m._Message->clone();                     
+00142                 _ReservedMethodIndexVar = m._ReservedMethodIndexVar;
+00143                 _ReservedHeritanceIndexVar = m._ReservedHeritanceIndexVar;                      
+00144                 _Performatif = m._Performatif;
+00145                 _comeFromC_PLUS = m._comeFromC_PLUS;
+00146                 _Dispatch = m._Dispatch;
+00147                 _ProtectSender = m._ProtectSender;
+00148         }
+00149 
+00150         IMessageBase::~IMessageBase()
+00151         {
+00152                 if(_MsgGroup != NULL) _MsgGroup->release();
+00153                 if(_SenderIsVolatile && _Sender != NULL) _Sender->release();
+00154                 if(_ReceiverIsVolatile && _Receiver != NULL) _Receiver->release();
+00155             if(_ContinuationIsVolatile && _Continuation != NULL) _Continuation->release();
+00156         }       
+00157 
+00158 
+00159         IObjectIA &IMessageBase::operator = (const IObjectIA &a)
+00160         {
+00161                 IMessageBase &b = (IMessageBase &)a;
+00162                 _Sender = b._Sender;
+00163                 if(_SenderIsVolatile && _Sender != NULL) _Sender->incRef();
+00164                 _Receiver = b._Receiver;
+00165                 if(_ReceiverIsVolatile && _Receiver != NULL) _Receiver->incRef();
+00166                 _Continuation = b._Continuation;
+00167                 if(_ContinuationIsVolatile && _Continuation != NULL) _Continuation->incRef();
+00168                 setGroup((IBasicMessageGroup &)b.getGroup());
+00169                 *_List = *b._List;
+00170                 return *this;
+00171         }
+00172 
+00173         void IMessageBase::setSender(IObjectIA *s, bool v)
+00174         {                                       
+00175                 if(_SenderIsVolatile) _Sender->release();
+00176                 _Sender = s;
+00177                 _SenderIsVolatile = v;
+00178         }
+00179 
+00180         void IMessageBase::setReceiver(IObjectIA *r, bool v)
+00181         {       
+00182                 if(_ReceiverIsVolatile) _Receiver->release();
+00183                 _Receiver = r;
+00184                 _ReceiverIsVolatile = v;
+00185         }
+00186 
+00187         void IMessageBase::setContinuation(IObjectIA *r, bool v)
+00188         {                                       
+00189                 if(_ContinuationIsVolatile) _Continuation->release();
+00190                 _Continuation = r;
+00191                 _ContinuationIsVolatile = v;
+00192         }
+00193 
+00194         bool IMessageBase::isEqual(const IBasicObjectIA &a) const
+00195         {
+00196                 IMessageBase &b = (IMessageBase &)a;                                            
+00197                 return _Sender->isEqual((const IBasicAgent &)b) && getGroup() == b.getGroup() && IListBasicManager::isEqual(a);
+00198         }       
+00199 
+00200         void IMessageBase::save(NLMISC::IStream &os)
+00201         {       
+00202                 IListBasicManager::save(os);
+00203                 if(_Sender != NULL)
+00204                 {
+00205                         bool t = true;
+00206                         os.serial(t);
+00207                         IWordNumRef &r = (IWordNumRef&)((const IWordNumRef&)*((IRefrence *)_Sender));
+00208                         ((CNumericIndex &)r.getNumIdent()).save(os);                    
+00209                 }
+00210                 else
+00211                 {
+00212                         bool t = false;
+00213                         os.serial(t);
+00214                 }
+00215 
+00216                 if(_Receiver != NULL)
+00217                 {
+00218                         bool t = true;
+00219                         os.serial(t);
+00220                         IWordNumRef &r = (IWordNumRef&)((const IWordNumRef&)*((IRefrence *)_Receiver));
+00221                         ((CNumericIndex &)r.getNumIdent()).save(os);                    
+00222                 }
+00223                 else
+00224                 {
+00225                         bool t = false;
+00226                         os.serial(t);
+00227                 }
+00228 
+00229                 if(_Continuation != NULL)
+00230                 {
+00231                         bool t = true;
+00232                         os.serial(t);
+00233                         IWordNumRef &r = (IWordNumRef&)((const IWordNumRef&)*((IRefrence *)_Continuation));
+00234                         ((CNumericIndex &)r.getNumIdent()).save(os);                    
+00235                 }
+00236                 else
+00237                 {
+00238                         bool t = false;
+00239                         os.serial(t);
+00240                 }
+00241                 os.serial( (NLAIC::CIdentType &) _MsgGroup->getType() );
+00242                 os.serial( *_MsgGroup );                
+00243 
+00244                 sint32 i = _Performatif;
+00245                 os.serial(i);
+00246                 os.serial(_comeFromC_PLUS);
+00247         }
+00248         
+00249         void IMessageBase::load(NLMISC::IStream &is)
+00250         {
+00251                 IListBasicManager::load(is);
+00252                 bool t;
+00253                 is.serial(t);           
+00254                 if(t)
+00255                 {
+00256                         CNumericIndex r(is);
+00257                         IRefrence *ref = CLocWordNumRef::getRef(r);
+00258                         if(ref != NULL)
+00259                         {
+00260                                 //if(_Sender) _Sender->release();
+00261                                 _Sender = ref;
+00262                                 //_Sender->incRef();
+00263                         }
+00264                         else
+00265                         {
+00266                                 //if(_Sender) _Sender->release();
+00267                                 setSender(new CProxyAgentMail(r.getId()) , true);
+00268                         }
+00269                         
+00270                 }
+00271                 else
+00272                 {                       
+00273                         _Sender = NULL;
+00274                 }
+00275                 
+00276                 is.serial(t);           
+00277                 if(t)
+00278                 {
+00279                         CNumericIndex r(is);
+00280                         IRefrence *ref = CLocWordNumRef::getRef(r);
+00281                         if(ref != NULL)
+00282                         {
+00283                                 //if(_Receiver) _Receiver->release();
+00284                                 _Receiver = ref;
+00285                                 //_Receiver->incRef();
+00286                         }
+00287                         else
+00288                         {
+00289                                 //if(_Receiver) _Receiver->release();
+00290                                 setReceiver(new CProxyAgentMail(r.getId()) , true);
+00291                         }
+00292                         
+00293                 }
+00294                 else
+00295                 {
+00296                         //if(_Receiver) _Receiver->release();
+00297                         _Receiver = NULL;
+00298                 }
+00299                 is.serial(t);           
+00300                 if(t)
+00301                 {
+00302                         CNumericIndex r(is);
+00303                         IRefrence *ref = CLocWordNumRef::getRef(r);
+00304                         if(ref != NULL)
+00305                         {
+00306                                 //if(_Continuation) _Continuation->release();
+00307                                 _Continuation = ref;
+00308                                 //_Continuation->incRef();
+00309                         }
+00310                         else
+00311                         {                               
+00312                                 //if(_Continuation) _Continuation->release();
+00313                                 setContinuation(new CProxyAgentMail(r.getId()) , true);
+00314                         }
+00315                         
+00316                 }
+00317                 else
+00318                 {
+00319                         //if(_Continuation) _Continuation->release();
+00320                         _Continuation = NULL;
+00321                 }
+00322 
+00323                 NLAIC::CIdentTypeAlloc id;
+00324                 is.serial( id );
+00325                 if(_MsgGroup) delete _MsgGroup;
+00326                 _MsgGroup = (IBasicMessageGroup *)id.allocClass();
+00327                 is.serial( (IBasicMessageGroup &)*_MsgGroup );                          
+00328                 sint32 i = _Performatif;
+00329                 is.serial(i);
+00330                 _Performatif = (TPerformatif)i;
+00331                 is.serial(_comeFromC_PLUS);
+00332         }
+00333 
+00334         void IMessageBase::getDebugString(std::string &t) const
+00335         {
+00336                 std::string a;
+00337                 if(_Sender != NULL) _Sender->getDebugString(a); 
+00338                 else a = "NULL";
+00339                 std::string b;
+00340                 IListBasicManager::getDebugString(b);
+00341                 std::string g;
+00342                 if(_MsgGroup != NULL) _MsgGroup->getDebugString(g);
+00343                 else g = "_MsgGroup = NULL";
+00344                 t += NLAIC::stringGetBuild("IMessageBase<%d>:\n_sender:'%s' _MsgGroup:'%s' Message:'%s' dispatch:%d",this,a.c_str(),g.c_str(),b.c_str(),_Dispatch);
+00345         }
+00346         
+00347 
+00348 
+00349         sint32 IMessageBase::getMethodIndexSize() const
+00350         {
+00351                 return IBaseGroupType::getMethodIndexSize() + _MLastM;
+00352         }       
+00353 
+00354         tQueue IMessageBase::isMember(const IVarName *className,const IVarName *methodName,const IObjectIA &p) const
+00355         {                       
+00356                 if(className == NULL)
+00357                 {
+00358                         tQueue a;
+00359                         for(int i = 0; i < _MLastM; i++)
+00360                         {
+00361                                 if( *methodName == IMessageBase::_Method[i].MethodName )
+00362                                 {                                       
+00363                                         CObjectType *c = new CObjectType(new NLAIC::CIdentType(*IAgent::IdAgent));
+00364                                         a.push( CIdMethod( IMessageBase::_Method[i].Index + IBaseGroupType::getMethodIndexSize(), 0.0, NULL, c) );                                      
+00365                                         break;
+00366                                 }
+00367                         }
+00368 
+00369                         if ( a.size() )
+00370                                 return a;
+00371                         else 
+00372                                 return IBaseGroupType::isMember( className, methodName, p);
+00373                 }
+00374                 return IListBasicManager::isMember(className,methodName,p);
+00375         }
+00376 
+00377         IObjectIA::CProcessResult IMessageBase::sendMessage(IObjectIA *m)
+00378         {
+00379                 return _Receiver->sendMessage(m);
+00380         }
+00381         
+00382         IObjectIA::CProcessResult IMessageBase::sendMessage(const IVarName &name,IObjectIA *m)
+00383         {
+00384                 return _Receiver->sendMessage(name,m);
+00385         }
+00386 
+00387         IObjectIA::CProcessResult IMessageBase::runMethodeMember(sint32 h, sint32 index,IObjectIA *p)
+00388         {
+00389                 return IBaseGroupType::runMethodeMember(h,index,p);
+00390         }
+00391 
+00392         IObjectIA::CProcessResult IMessageBase::runMethodeMember(sint32 index,IObjectIA *p)
+00393         {
+00394                 switch(index - IBaseGroupType::getMethodIndexSize())
+00395                 {
+00396                         case _TSender           :
+00397                                 {
+00398                                         IObjectIA::CProcessResult a;            
+00399                                         if ( _Sender != NULL )
+00400                                                 a.Result = new CLocalAgentMail( (IBasicAgent *) _Sender );                              
+00401                                         else
+00402                                         {
+00403                                                 a.Result = &DigitalType::NullOperator;
+00404                                                 a.Result->incRef();
+00405                                         }
+00406                                         return a;
+00407                                 }                       
+00408                                 break;
+00409 
+00410                         case _TReceiver :
+00411                                 {
+00412                                         IObjectIA::CProcessResult a;                            
+00413                                         if ( _Receiver != NULL )
+00414                                                 a.Result = new CLocalAgentMail( (IBasicAgent *) _Receiver );                            
+00415                                         else
+00416                                         {
+00417                                                 a.Result = &DigitalType::NullOperator;
+00418                                                 a.Result->incRef();
+00419                                         }
+00420                                         return a;
+00421                                 }       
+00422                                 break;
+00423 
+00424                         case _TContinuation     :
+00425                                 {
+00426                                         IObjectIA::CProcessResult a;                            
+00427                                         if ( _Continuation != NULL )
+00428                                                 a.Result = new CLocalAgentMail( (IBasicAgent *) _Continuation );                                
+00429                                         else
+00430                                         {
+00431                                                 a.Result = &DigitalType::NullOperator;
+00432                                                 a.Result->incRef();
+00433                                         }
+00434                                         return a;
+00435                                 }                       
+00436                                 break;
+00437                         
+00438                         case _TXchgReceiverIsSender     :
+00439                                 {
+00440                                         IObjectIA *t = _Sender;
+00441                                         _Sender = _Receiver;
+00442                                         _Receiver = t;
+00443                                         return IObjectIA::CProcessResult();
+00444                                 }
+00445                         case _TSetContinuation:
+00446                                 {
+00447                                         IObjectIA *o = (IObjectIA *)((IBaseGroupType *)p)->get();
+00448                                         //o->incRef();
+00449                                         setContinuation(o);
+00450                                         return IObjectIA::CProcessResult();
+00451                                 }
+00452 
+00453                         case _TSetSender:
+00454                                 {
+00455                                         IObjectIA *obj = (IObjectIA *) ((IBaseGroupType *)p)->get();                                    
+00456                                         CLocalAgentMail *o = dynamic_cast<CLocalAgentMail *>(obj);
+00457                                         if(o != NULL)
+00458                                                 setSender((IObjectIA *)o->getHost());
+00459                                         else
+00460                                                 setSender((IObjectIA *)obj);
+00461 
+00462                                         return IObjectIA::CProcessResult();
+00463                                 }                       
+00464 
+00465                         case _TInitProtocol:
+00466                                 {
+00467                                         _ReservedMethodIndexVar = -1;
+00468                                         _ReservedHeritanceIndexVar = 0;                                 
+00469                                         return IObjectIA::CProcessResult();                             
+00470                                 }
+00471                                 
+00472                         case _TProtcetSender:
+00473                                 {
+00474                                         setProtcetSender();                                     
+00475                                         return IObjectIA::CProcessResult();                             
+00476                                 }
+00477 
+00478                                 
+00479                         }
+00480                 return IBaseGroupType::runMethodeMember(index,p);
+00481         }
+00482 
+00483 
+00484         const NLAIC::CIdentType &CMessageList::getType() const
+00485         {
+00486                 return IdMessage;
+00487         }
+00488 
+00489         const NLAIC::CIdentType &CMessageVector::getType() const
+00490         {
+00491                 return IdMessageVector;
+00492         }
+00493 }
+
msg.cpp
