NeL: NLAIAGENT::IMessageBase class Reference

00047                 {
+00048                         op_add ,
+00049                         op_sub ,
+00050                         op_mul ,
+00051                         op_div ,
+00052                         op_eq ,
+00053                         op_inf ,
+00054                         op_sup ,
+00055                         op_inf_eq ,
+00056                         op_sup_eq ,
+00057                         op_not ,
+00058                         op_diff ,                       
+00059                         op_neg,
+00060                         op_last
+00061                 };      
+

00054                 {
+00055                         PUndefine,
+00056                         PExec,
+00057                         PAchieve,
+00058                         PAsk,
+00059                         PBreak,
+00060                         PTell,
+00061                         PKill,
+00062                         PError,                 
+00063                         PEven,
+00064                         PService
+00065                 };
+

00082                                   :IListBasicManager(),_Sender(NULL)
+00083         {
+00084                 _ReservedMethodIndexVar = -1;
+00085                 _ReservedHeritanceIndexVar = 0;
+00086                 _Receiver = NULL;
+00087                 _Continuation = NULL;
+00088                 _Performatif = PUndefine;
+00089                 _comeFromC_PLUS = true;         
+00090                 _ProtectSender = false;
+00091                 _SenderIsVolatile = false;
+00092                 _ReceiverIsVolatile = false;            
+00093                 _ContinuationIsVolatile = false;
+00094         }
+

00095                                                                      :IListBasicManager(g),_Sender(sender)
+00096         {
+00097                 _ReservedMethodIndexVar = -1;
+00098                 _ReservedHeritanceIndexVar = 0;
+00099                 _Receiver = NULL;
+00100                 _Continuation = NULL;
+00101                 _Performatif = PUndefine;
+00102                 _comeFromC_PLUS = true;         
+00103                 _ProtectSender = false;
+00104                 _SenderIsVolatile = false;
+00105                 _ReceiverIsVolatile = false;            
+00106                 _ContinuationIsVolatile = false;
+00107         }
+

00109                                                                                                     :
+00110                                                         IListBasicManager(g),_Sender(sender)
+00111         {
+00112                 _ReservedMethodIndexVar = -1;
+00113                 _ReservedHeritanceIndexVar = 0;
+00114                 _Receiver = NULL;
+00115                 _Continuation = NULL;
+00116                 _Performatif = PUndefine;
+00117                 _comeFromC_PLUS = true;         
+00118                 _ProtectSender = false;
+00119                 _SenderIsVolatile = false;
+00120                 _ReceiverIsVolatile = false;            
+00121                 _ContinuationIsVolatile = false;
+00122         }
+
+

00124                                                        :IListBasicManager(m._List != NULL ? (IBaseGroupType *)m._List->clone(): NULL)
+00125         {
+00126                 _Sender = m._Sender;
+00127                 _SenderIsVolatile = m._SenderIsVolatile;
+00128                 if(_SenderIsVolatile && _Sender != NULL) _Sender->incRef();
+00129                 _Receiver = m._Receiver;
+00130                 _ReceiverIsVolatile = m._ReceiverIsVolatile;
+00131                 if(_ReceiverIsVolatile && _Receiver != NULL) _Receiver->incRef();
+00132                 _Continuation = m._Continuation;
+00133                 _ContinuationIsVolatile = m._ContinuationIsVolatile;
+00134                 if(_ContinuationIsVolatile && _Continuation != NULL) _Continuation->incRef();
+00135                 _ReservedMethodIndexVar = m._ReservedMethodIndexVar;
+00136                 _ReservedHeritanceIndexVar = m._ReservedHeritanceIndexVar;                      
+00137                 _Performatif = m._Performatif;
+00138                 _comeFromC_PLUS = m._comeFromC_PLUS;            
+00139                 _ProtectSender = m._ProtectSender;
+00140         }
+

00143         {               
+00144                 if(_SenderIsVolatile && _Sender != NULL) _Sender->release();
+00145                 if(_ReceiverIsVolatile && _Receiver != NULL) _Receiver->release();
+00146             if(_ContinuationIsVolatile && _Continuation != NULL) _Continuation->release();
+00147         }       
+

00351         {
+00352                 return TQueue();
+00353         }
+

00174         {
+00175                 _List->clear();
+00176         }       
+

00124         {
+00125                 _List->cpy(o);
+00126         }
+

00094                 {
+00095                         return --_Ref;
+00096                 }
+

00170         {
+00171                 _List->erase(l);
+00172         }
+

00165         {
+00166                 _List->erase(obj);
+00167         }
+

00161         {
+00162                 _List->erase(o);
+00163         }
+

00157         {
+00158                 _List->eraseAll(obj);
+00159         }
+

00153         {
+00154                 _List->erase(obj);
+00155         }
+

00149         {
+00150                 return _List->find(obj);
+00151         }
+

00132         {
+00133                 return _List->get();
+00134         }
+

00117                 {
+00118                         return std::string("<unnamed>");
+00119                 }
+

00074                 {
+00075                         return _List->getConstIterator();
+00076                 }
+

00153                 {                       
+00154                         return _Continuation;
+00155                 }
+

00317         {
+00318                 std::string a;
+00319                 if(_Sender != NULL) _Sender->getDebugString(a); 
+00320                 else a = "NULL";
+00321                 std::string b;
+00322                 IListBasicManager::getDebugString(b);           
+00323                 t += NLAIC::stringGetBuild("IMessageBase<%d>:\n_sender:'%s' Message:'%s'",this,a.c_str(),b.c_str());
+00324         }
+

00140         {
+00141                 return _List->getFront();
+00142         }
+

00173                 {
+00174                         return _ReservedHeritanceIndexVar;
+00175                 }
+

00293                 {
+00294                         std::string s;
+00295                         getDebugString(s);
+00296                         return s;
+00297                 }
+

00069                 {
+00070                         return _List->getIterator();
+00071                 }
+

00113                 {
+00114                         return _List;
+00115                 }
+

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         }
+

00168                 {
+00169                         return _ReservedMethodIndexVar;
+00170                 }
+

00329         {
+00330                 return IBaseGroupType::getMethodIndexSize() + _MLastM;
+00331         }       
+

00166                 {
+00167                         IObjetOp *o = (IObjetOp *)clone();                      
+00168                         o->neg();
+00169                         return o;
+00170                 }
+

00132                 {
+00133                         return _Performatif;
+00134                 }
+

00148                 {                       
+00149                         return _Receiver;
+00150                 }
+

00100                 {
+00101                         return _Ref;
+00102                 }
+

00143                 {                       
+00144                         return _Sender;
+00145                 }
+

00262                 {
+00263                         return getStaticMember(getStaticMemberIndex(compName));
+00264                 }
+

00194         {
+00195                 return NULL;
+00196         }
+

00189         {
+00190                 return -1;
+00191         }
+

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         }
+

00081                 {
+00082                         _Ref ++;
+00083                 }
+

00117         {
+00118                 
+00119         }
+

00257         {
+00258                 return -1;
+00259         }
+

00185         {
+00186                 IMessageBase &b = (IMessageBase &)a;                                            
+00187                 return _Sender->isEqual((const IBasicAgent &)b) && IListBasicManager::isEqual(a);
+00188         }       
+

00357         {
+00358                 return true;
+00359         }
+

00334         {                       
+00335                 if(className == NULL)
+00336                 {
+00337                         TQueue a;
+00338                         for(int i = 0; i < _MLastM; i++)
+00339                         {
+00340                                 if( *methodName == IMessageBase::_Method[i].MethodName )
+00341                                 {                                       
+00342                                         CObjectType *c = new CObjectType(new NLAIC::CIdentType(*IAgent::IdAgent));
+00343                                         a.push( CIdMethod( IMessageBase::_Method[i].Index + IBaseGroupType::getMethodIndexSize(), 0.0, NULL, c) );                                      
+00344                                         break;
+00345                                 }
+00346                         }
+00347 
+00348                         if ( a.size() )
+00349                                 return a;
+00350                         else 
+00351                                 return IBaseGroupType::isMember( className, methodName, p);
+00352                 }
+00353                 return IListBasicManager::isMember(className,methodName,p);
+00354         }
+

00106         {
+00107                 return _List->isTrue();
+00108         }
+

00237         {
+00238                 IListBasicManager::load(is);
+00239                 bool t;
+00240                 is.serial(t);           
+00241                 if(t)
+00242                 {
+00243                         CNumericIndex r(is);
+00244                         IRefrence *ref = CLocWordNumRef::getRef(r);
+00245                         if(ref != NULL)
+00246                         {
+00247                                 //if(_Sender) _Sender->release();
+00248                                 _Sender = ref;
+00249                                 //_Sender->incRef();
+00250                         }
+00251                         else
+00252                         {
+00253                                 //if(_Sender) _Sender->release();
+00254                                 setSender(new CProxyAgentMail(r.getId()) , true);
+00255                         }
+00256                         
+00257                 }
+00258                 else
+00259                 {                       
+00260                         _Sender = NULL;
+00261                 }
+00262                 
+00263                 is.serial(t);           
+00264                 if(t)
+00265                 {
+00266                         CNumericIndex r(is);
+00267                         IRefrence *ref = CLocWordNumRef::getRef(r);
+00268                         if(ref != NULL)
+00269                         {
+00270                                 //if(_Receiver) _Receiver->release();
+00271                                 _Receiver = ref;
+00272                                 //_Receiver->incRef();
+00273                         }
+00274                         else
+00275                         {
+00276                                 //if(_Receiver) _Receiver->release();
+00277                                 setReceiver(new CProxyAgentMail(r.getId()) , true);
+00278                         }
+00279                         
+00280                 }
+00281                 else
+00282                 {
+00283                         //if(_Receiver) _Receiver->release();
+00284                         _Receiver = NULL;
+00285                 }
+00286                 is.serial(t);           
+00287                 if(t)
+00288                 {
+00289                         CNumericIndex r(is);
+00290                         IRefrence *ref = CLocWordNumRef::getRef(r);
+00291                         if(ref != NULL)
+00292                         {
+00293                                 //if(_Continuation) _Continuation->release();
+00294                                 _Continuation = ref;
+00295                                 //_Continuation->incRef();
+00296                         }
+00297                         else
+00298                         {                               
+00299                                 //if(_Continuation) _Continuation->release();
+00300                                 setContinuation(new CProxyAgentMail(r.getId()) , true);
+00301                         }
+00302                         
+00303                 }
+00304                 else
+00305                 {
+00306                         //if(_Continuation) _Continuation->release();
+00307                         _Continuation = NULL;
+00308                 }
+00309                 
+00310                 sint32 i = _Performatif;
+00311                 is.serial(i);
+00312                 _Performatif = (TPerformatif)i;
+00313                 is.serial(_comeFromC_PLUS);
+00314         }
+

00102                 {
+00103                         std::string text;
+00104                         text = NLAIC::stringGetBuild("opertor <IObjectIA &neg()> note implemented for the '%s' interface",(const char *)getType());
+00105                         throw NLAIE::CExceptionNotImplemented(text.c_str());
+00106                         return *this;
+00107                 }               
+

00203                 {
+00204                         return *this * *a;
+00205 
+00206                 }
+

00148                 {
+00149                         std::string text;
+00150                         text = NLAIC::stringGetBuild("opertor <virtual IObjetOp *operator * (const IObjetOp &a)  const> note implemented for the '%s' interface",(const char *)getType());
+00151                         throw NLAIE::CExceptionNotImplemented(text.c_str());
+00152                         return (IObjetOp *)this;
+00153                 }
+

00183                 {
+00184                         return *this *= *a;
+00185 
+00186                 }
+

00111                 {
+00112                         std::string text;
+00113                         text = NLAIC::stringGetBuild("opertor <IObjectIA &operator *= (const IObjectIA &a)> note implemented for the '%s' interface",(const char *)getType());
+00114                         throw NLAIE::CExceptionNotImplemented(text.c_str());
+00115                         return *this;
+00116                 }
+

00108                 {
+00109                         return _List;
+00110                 }
+

00110         {
+00111                 return !(*_List);
+00112         }
+

00253                 {
+00254                         std::string text;
+00255                         text = NLAIC::stringGetBuild("opertor <virtual IObjetOp *operator != (const IObjetOp &a)  const> note implemented for the '%s' interface",(const char *)getType());
+00256                         throw NLAIE::CExceptionNotImplemented(text.c_str());
+00257                         return (IObjetOp *)this;
+00258                 }               
+

00194                 {
+00195                         return *this + *a;
+00196                 }
+

00132                 {
+00133                         std::string text;
+00134                         text = NLAIC::stringGetBuild("opertor <virtual IObjetOp *operator + (const IObjetOp &a)  const> note implemented for the '%s' interface",(const char *)getType());
+00135                         throw NLAIE::CExceptionNotImplemented(text.c_str());
+00136                         return (IObjetOp *)this;
+00137                 }
+

00081         {
+00082                 push(a);
+00083                 return *this;
+00084         }
+

00085         {
+00086                 _List->cpy(a);
+00087                 return *this;
+00088         }
+

00198                 {
+00199                         return *this - *a;
+00200 
+00201                 }
+

00140                 {
+00141                         std::string text;
+00142                         text = NLAIC::stringGetBuild("opertor <virtual IObjetOp *operator - (const IObjetOp &a)  const> note implemented for the '%s' interface",(const char *)getType());
+00143                         throw NLAIE::CExceptionNotImplemented(text.c_str());
+00144                         return (IObjetOp *)this;
+00145                 }
+

00087         {
+00088                 erase(a);
+00089                 return *this;
+00090         }
+

00091         {               
+00092                 _List->erase(a);
+00093                 return *this;
+00094         }
+

00208                 {
+00209                         return *this / *a;
+00210 
+00211                 }
+

00156                 {
+00157                         std::string text;
+00158                         text = NLAIC::stringGetBuild("opertor <virtual IObjetOp *operator / (const IObjetOp &a)  const> note implemented for the '%s' interface",(const char *)getType());
+00159                         throw NLAIE::CExceptionNotImplemented(text.c_str());
+00160                         return (IObjetOp *)this;
+00161                 }
+

00188                 {
+00189                         return *this /= *a;
+00190 
+00191                 }
+

00120                 {
+00121                         std::string text;
+00122                         text = NLAIC::stringGetBuild("opertor <IObjectIA &operator /= (const IObjectIA &a)> note implemented for the '%s' interface",(const char *)getType());
+00123                         throw NLAIE::CExceptionNotImplemented(text.c_str());
+00124                         return *this;
+00125                 }       
+

00214                 {
+00215                         std::string text;
+00216                         text = NLAIC::stringGetBuild("opertor <virtual IObjetOp *operator < (const IObjetOp &a)  const> note implemented for the '%s' interface",(const char *)getType());
+00217                         throw NLAIE::CExceptionNotImplemented(text.c_str());
+00218                         return (IObjetOp *)this;
+00219                 }
+

00230                 {
+00231                         std::string text;
+00232                         text = NLAIC::stringGetBuild("opertor <virtual IObjetOp *operator <= (const IObjetOp &a)  const> note implemented for the '%s' interface",(const char *)getType());
+00233                         throw NLAIE::CExceptionNotImplemented(text.c_str());
+00234                         return (IObjetOp *)this;
+00235                 }
+

00151         {
+00152                 IMessageBase &b = (IMessageBase &)a;
+00153                 _Sender = b._Sender;
+00154                 if(_SenderIsVolatile && _Sender != NULL) _Sender->incRef();
+00155                 _Receiver = b._Receiver;
+00156                 if(_ReceiverIsVolatile && _Receiver != NULL) _Receiver->incRef();
+00157                 _Continuation = b._Continuation;
+00158                 if(_ContinuationIsVolatile && _Continuation != NULL) _Continuation->incRef();           
+00159                 *_List = *b._List;
+00160                 return *this;
+00161         }
+

00135         {                                               
+00136                 if(a.getType() == getType() ) return isEqual(a);                        
+00137                 return false;
+00138         }               
+

00261                 {
+00262                         std::string text;
+00263                         text = NLAIC::stringGetBuild("opertor <virtual IObjetOp *operator == (const IObjetOp &a)  const> note implemented for the '%s' interface",(const char *)getType());
+00264                         throw NLAIE::CExceptionNotImplemented(text.c_str());
+00265                         return (IObjetOp *)this;
+00266                 }
+

00222                 {
+00223                         std::string text;
+00224                         text = NLAIC::stringGetBuild("opertor <virtual IObjetOp *operator > (const IObjetOp &a)  const> note implemented for the '%s' interface",(const char *)getType());
+00225                         throw NLAIE::CExceptionNotImplemented(text.c_str());
+00226                         return (IObjetOp *)this;
+00227                 }
+

00238                 {
+00239                         std::string text;
+00240                         text = NLAIC::stringGetBuild("opertor <virtual IObjetOp *operator >= (const IObjetOp &a)  const> note implemented for the '%s' interface",(const char *)getType());
+00241                         throw NLAIE::CExceptionNotImplemented(text.c_str());
+00242                         return (IObjetOp *)this;
+00243                 }
+

00098         {       
+00099 #ifdef NL_DEBUG
+00100                 sint s = _List->size();
+00101 #endif
+00102                 return (*_List)[index];
+00103         }       
+

00128         {
+00129                 return _List->pop();
+00130         }
+

00136         {
+00137                 return _List->popFront();
+00138         }
+

00183                 {
+00184                         _ProtectSender = true;
+00185                 }
+

00114         {
+00115                 _List->push(o);
+00116         }
+

00119         {
+00120                 _List->pushFront(o);
+00121         }
+

00087                 {
+00088                         if(decRef() == 0) 
+00089                                         delete this;
+00090                 }
+

00098 {return IObjectIA::ProcessRun;}
+

00372         {
+00373                 switch(index - IBaseGroupType::getMethodIndexSize())
+00374                 {
+00375                         case _TSender           :
+00376                                 {
+00377                                         IObjectIA::CProcessResult a;            
+00378                                         if ( _Sender != NULL )
+00379                                                 a.Result = new CLocalAgentMail( (IBasicAgent *) _Sender );                              
+00380                                         else
+00381                                         {
+00382                                                 a.Result = &DigitalType::NullOperator;
+00383                                                 a.Result->incRef();
+00384                                         }
+00385                                         return a;
+00386                                 }                       
+00387                                 break;
+00388 
+00389                         case _TReceiver :
+00390                                 {
+00391                                         IObjectIA::CProcessResult a;                            
+00392                                         if ( _Receiver != NULL )
+00393                                                 a.Result = new CLocalAgentMail( (IBasicAgent *) _Receiver );                            
+00394                                         else
+00395                                         {
+00396                                                 a.Result = &DigitalType::NullOperator;
+00397                                                 a.Result->incRef();
+00398                                         }
+00399                                         return a;
+00400                                 }       
+00401                                 break;
+00402 
+00403                         case _TContinuation     :
+00404                                 {
+00405                                         IObjectIA::CProcessResult a;                            
+00406                                         if ( _Continuation != NULL )
+00407                                                 a.Result = new CLocalAgentMail( (IBasicAgent *) _Continuation );                                
+00408                                         else
+00409                                         {
+00410                                                 a.Result = &DigitalType::NullOperator;
+00411                                                 a.Result->incRef();
+00412                                         }
+00413                                         return a;
+00414                                 }                       
+00415                                 break;
+00416                         
+00417                         case _TXchgReceiverIsSender     :
+00418                                 {
+00419                                         IObjectIA *t = _Sender;
+00420                                         _Sender = _Receiver;
+00421                                         _Receiver = t;
+00422                                         return IObjectIA::CProcessResult();
+00423                                 }
+00424                         case _TSetContinuation:
+00425                                 {
+00426                                         IObjectIA *o = (IObjectIA *)((IBaseGroupType *)p)->get();
+00427                                         //o->incRef();
+00428                                         setContinuation(o);
+00429                                         return IObjectIA::CProcessResult();
+00430                                 }
+00431 
+00432                         case _TSetSender:
+00433                                 {
+00434                                         IObjectIA *obj = (IObjectIA *) ((IBaseGroupType *)p)->get();                                    
+00435                                         CLocalAgentMail *o = dynamic_cast<CLocalAgentMail *>(obj);
+00436                                         if(o != NULL)
+00437                                                 setSender((IObjectIA *)o->getHost());
+00438                                         else
+00439                                                 setSender((IObjectIA *)obj);
+00440 
+00441                                         return IObjectIA::CProcessResult();
+00442                                 }                       
+00443 
+00444                         case _TInitProtocol:
+00445                                 {
+00446                                         _ReservedMethodIndexVar = -1;
+00447                                         _ReservedHeritanceIndexVar = 0;                                 
+00448                                         return IObjectIA::CProcessResult();                             
+00449                                 }
+00450                                 
+00451                         case _TProtcetSender:
+00452                                 {
+00453                                         protectSender();                                        
+00454                                         return IObjectIA::CProcessResult();                             
+00455                                 }
+00456 
+00457                                 
+00458                         }
+00459                 return IBaseGroupType::runMethodeMember(index,p);
+00460         }
+

00367         {
+00368                 return IBaseGroupType::runMethodeMember(h,index,p);
+00369         }
+

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         }
+

00191         {       
+00192                 IListBasicManager::save(os);
+00193                 if(_Sender != NULL)
+00194                 {
+00195                         bool t = true;
+00196                         os.serial(t);
+00197                         IWordNumRef &r = (IWordNumRef&)((const IWordNumRef&)*((IRefrence *)_Sender));
+00198                         ((CNumericIndex &)r.getNumIdent()).save(os);                    
+00199                 }
+00200                 else
+00201                 {
+00202                         bool t = false;
+00203                         os.serial(t);
+00204                 }
+00205 
+00206                 if(_Receiver != NULL)
+00207                 {
+00208                         bool t = true;
+00209                         os.serial(t);
+00210                         IWordNumRef &r = (IWordNumRef&)((const IWordNumRef&)*((IRefrence *)_Receiver));
+00211                         ((CNumericIndex &)r.getNumIdent()).save(os);                    
+00212                 }
+00213                 else
+00214                 {
+00215                         bool t = false;
+00216                         os.serial(t);
+00217                 }
+00218 
+00219                 if(_Continuation != NULL)
+00220                 {
+00221                         bool t = true;
+00222                         os.serial(t);
+00223                         IWordNumRef &r = (IWordNumRef&)((const IWordNumRef&)*((IRefrence *)_Continuation));
+00224                         ((CNumericIndex &)r.getNumIdent()).save(os);                    
+00225                 }
+00226                 else
+00227                 {
+00228                         bool t = false;
+00229                         os.serial(t);
+00230                 }               
+00231                 sint32 i = _Performatif;
+00232                 os.serial(i);
+00233                 os.serial(_comeFromC_PLUS);
+00234         }
+

00192                 {
+00193                         return _ProtectSender;
+00194                 }
+

00362         {
+00363                 return _Receiver->sendMessage(name,m);
+00364         }
+

00357         {
+00358                 return _Receiver->sendMessage(m);
+00359         }
+

00329                 {
+00330                         if ( f.isReading() )
+00331                                 load( f );
+00332                         else
+00333                                 save( f );
+00334                 }
+

00059                 {
+00060                         _List->set(i,o);
+00061                 }
+

00178         {                                       
+00179                 if(_ContinuationIsVolatile) _Continuation->release();
+00180                 _Continuation = r;
+00181                 _ContinuationIsVolatile = v;
+00182         }
+

00107                 {
+00108                         if(_List != NULL) _List->release();
+00109                         _List = g;
+00110                 }
+

00162                 {
+00163                         _ReservedMethodIndexVar = n;
+00164                         _ReservedHeritanceIndexVar = h;
+00165                 }
+

00127                 {
+00128                         _Performatif = p;
+00129                 }
+

00171         {       
+00172                 if(_ReceiverIsVolatile) _Receiver->release();
+00173                 _Receiver = r;
+00174                 _ReceiverIsVolatile = v;
+00175         }
+

00164         {                                       
+00165                 if(_SenderIsVolatile) _Sender->release();
+00166                 _Sender = s;
+00167                 _SenderIsVolatile = v;
+00168         }
+

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         }
+

00269                 {
+00270                         return setStaticMember(getStaticMemberIndex(compName),change);
+00271                 }
+

00144         {
+00145                 return _List->size();
+00146         }
+

00187                 {
+00188                         _ProtectSender = false;
+00189                 }
+

 
+        {
+                IMessageBase::CMethodCall(_SENDER_,_TSender),           
+                IMessageBase::CMethodCall(_RECEIVER_,_TReceiver),               
+                IMessageBase::CMethodCall(_CONTINUATION_,_TContinuation),
+                IMessageBase::CMethodCall(_SETCONTINUATION_,_TSetContinuation),
+                IMessageBase::CMethodCall("XChangeReceiverSender",_TXchgReceiverIsSender),
+                IMessageBase::CMethodCall("ProtcetSender",_TProtcetSender),
+                IMessageBase::CMethodCall("InitProtocol",_TInitProtocol),
+                IMessageBase::CMethodCall("SetSender",_TSetSender)              
+                
+        }
+


[NOHEADER]
virtual IObjetOp *	operator * (const IObjetOp &)
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp *	operator+ (const IObjetOp &)
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp *	operator- (const IObjetOp &)
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp *	operator/ (const IObjetOp &)
	throw (NLAIE::CExceptionNotImplemented)
Public Types
enum	TOpId { + op_add, +op_sub, +op_mul, +op_div, + + op_eq, +op_inf, +op_sup, +op_inf_eq, + + op_sup_eq, +op_not, +op_diff, +op_neg, + + op_last + + }
enum	TPerformatif { + PUndefine, +PExec, +PAchieve, +PAsk, + + PBreak, +PTell, +PKill, +PError, + + PEven, +PService + + }
Public Member Functions
virtual TQueue	canProcessMessage (const IVarName &)
virtual const IBasicType *	clone () const=0
sint32	decRef ()
	Decrement the reference of an object.
virtual void	getDebugString (std::string &t) const
virtual const std::string	getInfo ()
const IBaseGroupType *	getMessageGroup () const
virtual std::string	getMethodeMemberDebugString (sint32, sint32) const
virtual sint32	getMethodIndexSize () const
virtual IObjetOp *	getNeg () const
const TPerformatif &	getPerformatif () const
const sint32 &	getRef () const
	get the refence count.
const IObjectIA *	getStaticMember (const IVarName &compName) const
virtual const IObjectIA *	getStaticMember (sint32) const
virtual sint32	getStaticMemberIndex (const IVarName &) const
virtual sint32	getStaticMemberSize () const
virtual const CIdentType &	getType () const=0
	IMessageBase (const IMessageBase &m)
	IMessageBase (IObjectIA sender, IBasicMessageGroup &msg_group, IBaseGroupType g)
	IMessageBase (IObjectIA sender, IBaseGroupType g)
	IMessageBase ()
void	incRef ()
	Inc a reference. We use this when we have to conserve a pointer memeory for exemple in a list.
virtual void	init (IObjectIA *)
virtual bool	isEqual (const IBasicObjectIA &a) const
virtual bool	isLocal ()
	If the result is true the object is loclal else its a representation of an object on the server. By the method return true.
virtual TQueue	isMember (const IVarName className, const IVarName methodName, const IObjectIA &p) const
virtual void	load (NLMISC::IStream &is)
virtual const IBasicType *	newInstance () const=0
virtual IObjetOp *	operator * (IObjetOp *a)
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp &	operator = (IObjetOp a)
	throw (NLAIE::CExceptionNotImplemented)
	operator const IBaseGroupType * () const
	Get the list of message contents.
virtual IObjetOp *	operator!= (IObjetOp &) const
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp *	operator+ (IObjetOp *a)
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp *	operator- (IObjetOp *a)
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp *	operator/ (IObjetOp *a)
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp &	operator/= (IObjetOp *a)
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp *	operator< (IObjetOp &) const
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp *	operator<= (IObjetOp &) const
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjectIA &	operator= (const IObjectIA &a)
	Clear the list.
bool	operator== (const IBasicObjectIA &classType) const
virtual IObjetOp *	operator== (IObjetOp &) const
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp *	operator> (IObjetOp &) const
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp *	operator>= (IObjetOp &) const
	throw (NLAIE::CExceptionNotImplemented)
void	protectSender ()
	The sendMessage set automatically the sender on the message header, if user want keep sender have to use this method.
virtual void	release ()
	Release allow to release the pointer. The last release when the _Ref is nul delete the object.
virtual IObjectIA::CProcessResult	runMethodeMember (sint32, IObjectIA *)
virtual IObjectIA::CProcessResult	runMethodeMember (sint32, sint32, IObjectIA *)
virtual const CProcessResult &	runStep ()
virtual void	save (NLMISC::IStream &os)
bool	senderIsProtected () const
virtual CProcessResult	sendMessage (const IVarName &, IObjectIA *)
virtual CProcessResult	sendMessage (IObjectIA *)
virtual void	serial (NLMISC::IStream &f) throw (NLMISC::EStream)
void	setMessageGroup (IBaseGroupType *g)
void	setPerformatif (TPerformatif p)
virtual bool	setStaticMember (sint32, IObjectIA *)
bool	setStaticMember (const IVarName &compName, IObjectIA *change)
void	unprotectSender ()
virtual	~IMessageBase ()
Static Public Attributes
TProcessStatement	ProcessBuzzy = processBuzzy
TProcessStatement	ProcessEnd = processEnd
TProcessStatement	ProcessError = processError
TProcessStatement	ProcessIdle = processIdle
TProcessStatement	ProcessLocked = processLocked
CProcessResult	ProcessNotComplit = IObjectIA::CProcessResult(processNotComplete)
CProcessResult	ProcessRun = IObjectIA::CProcessResult()
Protected Attributes
IBaseGroupType *	_List
Private Attributes
bool	_comeFromC_PLUS
	This bool allow to know here the message come from: scriptes agent or hard coded agent.
IObjectIA *	_Continuation
	This adresse is when receiver have to inform something at a third agent.
bool	_ContinuationIsVolatile
TPerformatif	_Performatif
	This variable define the performatif for agent dialog protocole.
bool	_ProtectSender
	Sender can be change on a multible send/run messages.
IObjectIA *	_Receiver
	witch Agent the message have to be achieve.
bool	_ReceiverIsVolatile
sint32	_ReservedHeritanceIndexVar
	if the message come from script then this reserved variable represent the offset of the base class which the Run(MSG) is.
sint32	_ReservedMethodIndexVar
	This reserved variable represent the offset of the Run(MSG) if the message come from script.
IObjectIA *	_Sender
	Who send the message.
bool	_SenderIsVolatile
	statu of the sender, if true that indicate that the IObjectIA *_Sender pointer will be destruct on the destructor.
Static Private Attributes
CMethodCall	_Method []

NLAIAGENT::IMessageBase Class Reference

Detailed Description

[NOHEADER]

Public Types

Public Member Functions

Static Public Attributes

Protected Attributes

Private Attributes

Static Private Attributes

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Field Documentation