NeL: NLAIAGENT::COnChangeMsg 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                 };
+

00052                                                        : CMessageScript(m)
+00053         {
+00054         }
+

00033                                                                                       :CMessageScript(b)
+00034         {
+00035                 CGroupType *x = new CGroupType();               
+00036                 setMessageGroup(x);
+00037         }
+

00039                                                             :CMessageScript(b)
+00040         {               
+00041                 CGroupType *x = new CGroupType();               
+00042                 setMessageGroup(x);             
+00043         }
+

00045                                                     :
+00046                         CMessageScript((NLAISCRIPT::CMessageClass *)NLAISCRIPT::COnChangeMsgClass::IdOnChangeMsgClass.getFactory()->getClass())
+00047         {               
+00048                 CGroupType *x = new CGroupType();               
+00049                 setMessageGroup(x);             
+00050         }
+
+

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

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

00057         {
+00058                                 
+00059                 const NLAIC::IBasicType *x = new COnChangeMsg(*this);
+00060                 
+00061                 return x;
+00062         }
+

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

00083         {
+00084                 return IMessageBase::getMethodIndexSize();
+00085         }
+

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

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

00153                 {                       
+00154                         return _Continuation;
+00155                 }
+

00103                         {
+00104                                 return _MessageClass;
+00105                         }
+

00073         {
+00074                 double i = ((const INombreDefine *)getFront())->getNumber();
+00075                 if(i != 0.0)
+00076                 {
+00077                         std::string txt;
+00078                         get()->getDebugString(txt);
+00079                         t += NLAIC::stringGetBuild("COnChangeMsg<true,%s>",txt.c_str());
+00080                 }
+00081                 else
+00082                 {
+00083                         t = "COnChangeMsg<false,NULL>";
+00084                 }
+00085         }       
+

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

00105         {
+00106 #ifdef NL_DEBUG
+00107                 if ( index >= _MessageClass->getMethodIndexSize())
+00108                 {
+00109                         throw NLAIE::CExceptionIndexError();
+00110                 }
+00111 #endif
+00112                 return (NLAISCRIPT::IOpCode *)_MessageClass->getBrancheCode(index).getCode();
+00113         }
+

00089         {
+00090 #ifdef NL_DEBUG
+00091                 if ( index >= _MessageClass->getMethodIndexSize())
+00092                 {
+00093                         throw NLAIE::CExceptionIndexError();
+00094                 }
+00095 
+00096                 if ( inheritance >= _MessageClass->sizeVTable())
+00097                 {
+00098                         throw NLAIE::CExceptionIndexError();
+00099                 }
+00100 #endif
+00101                 return (NLAISCRIPT::IOpCode *)_MessageClass->getBrancheCode(inheritance,index).getCode();
+00102         }
+

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

00078         {
+00079                 return IMessageBase::getMethodIndexSize() + _MessageClass->getMethodIndexSize();
+00080         }
+

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

00280         {
+00281 #ifdef NL_DEBUG
+00282                 if ( index >= size() )
+00283                 {
+00284                         throw NLAIE::CExceptionIndexError();
+00285                 }
+00286 #endif
+00287                 return (*this)[ index ];                
+00288         }
+

00291         {
+00292                 return _MessageClass->getStaticMemberIndex(name);
+00293         }
+

00296         {
+00297                 return 0;
+00298         }
+

00065         {
+00066                 if ( getCreatorClass() ) 
+00067                         return getCreatorClass()->getType();
+00068                 else
+00069                         return IdOnChangeMsg;
+00070         }       
+

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

00117         {
+00118                 
+00119         }
+

00259         {
+00260                 return _MessageClass->isClassInheritedFrom( class_name );
+00261         }       
+

00380         {
+00381                 return IMessageBase::isEqual(a);
+00382         }
+

00357         {
+00358                 return true;
+00359         }
+

00301         {       
+00302 
+00303                 TQueue result = IMessageBase::isMember(className, methodName, param);
+00304                 
+00305                 if ( result.size()  )
+00306                 {
+00307                         return result;
+00308                 }
+00309 
+00310                 if( *methodName == CStringVarName("send") )
+00311                 {
+00312                         TQueue r;
+00313                         NLAISCRIPT::COperandVoid typeR;
+00314                         NLAISCRIPT::CObjectUnknown *t = new NLAISCRIPT::CObjectUnknown((NLAISCRIPT::IOpType *)typeR.clone());                   
+00315                         r.push(CIdMethod(0,0.0,NULL,t));
+00316                         return r;
+00317                 }
+00318 
+00319                 return result;
+00320         }
+

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

00328         {
+00329                 IMessageBase::load(is);
+00330         }
+

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

00053                 {
+00054                         return new COnChangeMsg();
+00055                 }
+

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

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

00393         {
+00394                 return IObjectIA::ProcessRun;
+00395         }
+

00188         {
+00189                 if(c->getType() != NLAISCRIPT::CCodeContext::IdCodeContext)
+00190                 {
+00191                         return IMessageBase::runMethodeMember(index, c);
+00192                 }
+00193 
+00194                 NLAISCRIPT::IOpCode *opPtr = NULL;
+00195                 NLAISCRIPT::CCodeContext &context = (NLAISCRIPT::CCodeContext &)*c;
+00196 
+00197                 sint32 i = index - getBaseMethodCount();
+00198                 if(i < 0)
+00199                 {
+00200                         /*if (context.ContextDebug.Active)
+00201                         {
+00202                                 context.ContextDebug.Param.push_back(&listBidon);
+00203                                 listBidon.incRef();
+00204                         }*/
+00205 
+00206                         IObjectIA::CProcessResult r = IMessageBase::runMethodeMember(index,(IObjectIA *)context.Param.back());
+00207                         if(r.Result != NULL)
+00208                         {
+00209                                 context.Stack++;
+00210                                 context.Stack[(int)context.Stack] = r.Result;
+00211                         }
+00212                         r.Result = NULL;
+00213                         return r;
+00214                 }
+00215                 else
+00216                 {
+00217                         opPtr = getMethode(i);
+00218                 }
+00219 
+00220                 IObjectIA::CProcessResult r;
+00221 
+00222                 if(opPtr)
+00223                 {
+00224                         NLAISCRIPT::IOpCode &op = *opPtr;
+00225                         NLAISCRIPT::CCodeBrancheRun *opTmp = context.Code;
+00226                         sint32 ip = (uint32)*context.Code;
+00227                         context.Code = (NLAISCRIPT::CCodeBrancheRun *)&op;              
+00228                         *context.Code = 0;
+00229 
+00230                         /*:TProcessStatement k = IObjectIA::ProcessIdle;
+00231 
+00232                         while(k != IObjectIA::ProcessEnd)
+00233                         {
+00234                                 k = op.run(context);    
+00235                         }*/             
+00236 
+00237                         r = ((NLAISCRIPT::ICodeBranche *)opPtr)->run(context);
+00238 
+00239                         // If we are in Debug Mode
+00240                         if (context.ContextDebug.Active)
+00241                         {
+00242                                 context.ContextDebug.callStackPop();
+00243                         }
+00244 
+00245                         *context.Code = ip;
+00246                         context.Code = opTmp;
+00247                 }
+00248                 else
+00249                 {
+00250                         throw NLAIE::CExceptionUnReference("CMessageScript::runMethodeMember(sint32, IObjectIA *) because code is null");
+00251                 }
+00252                 /*IObjectIA::CProcessResult r;
+00253                 r.Result = NULL;
+00254                 r.ResultState = k;*/
+00255                 return r;
+00256         }       
+

00117         {
+00118                 if(c->getType() != NLAISCRIPT::CCodeContext::IdCodeContext)
+00119                 {
+00120                         return IMessageBase::runMethodeMember(inheritance,index, c);
+00121                 }
+00122 
+00123                 NLAISCRIPT::IOpCode *opPtr = NULL;
+00124                 NLAISCRIPT::CCodeContext &context = (NLAISCRIPT::CCodeContext &)*c;
+00125 
+00126                 sint32 i = index - getBaseMethodCount();
+00127                 if(i < 0)
+00128                 {
+00129                         /*if (context.ContextDebug.Active)
+00130                         {
+00131                                 context.ContextDebug.Param.push_back(&listBidon);
+00132                                 listBidon.incRef();
+00133                         }*/
+00134 
+00135                         IObjectIA::CProcessResult r = IMessageBase::runMethodeMember(index,(IObjectIA *)context.Param.back());
+00136                         if(r.Result != NULL)
+00137                         {
+00138                                 context.Stack++;
+00139                                 context.Stack[(int)context.Stack] = r.Result;
+00140                         }
+00141                         r.Result = NULL;
+00142                         return r;
+00143                 }
+00144                 else
+00145                 {
+00146                         opPtr = getMethode( inheritance, i);
+00147                 }
+00148                 
+00149                 IObjectIA::CProcessResult r;
+00150 
+00151                 if(opPtr)
+00152                 {
+00153                         NLAISCRIPT::IOpCode &op = *opPtr;
+00154                         NLAISCRIPT::CCodeBrancheRun *opTmp = context.Code;
+00155                         sint32 ip = (uint32)*context.Code;
+00156                         context.Code = (NLAISCRIPT::CCodeBrancheRun *)&op;              
+00157                         *context.Code = 0;
+00158 
+00159                         /*TProcessStatement k = IObjectIA::ProcessIdle;
+00160 
+00161                         while(k != IObjectIA::ProcessEnd)
+00162                         {
+00163                                 k = op.run(context);    
+00164                         }*/
+00165                         
+00166                         r = ((NLAISCRIPT::ICodeBranche *)opPtr)->run(context);
+00167 
+00168                         // If we are in Debug Mode
+00169                         if (context.ContextDebug.Active)
+00170                         {
+00171                                 context.ContextDebug.callStackPop();
+00172                         }
+00173                         
+00174                         *context.Code = ip;
+00175                         context.Code = opTmp;
+00176                 }
+00177                 else
+00178                 {
+00179                         throw NLAIE::CExceptionUnReference("CMessageScript::runMethodeMember(sint32 , sint32, IObjectIA *) because code is null");
+00180                 }
+00181                 /*IObjectIA::CProcessResult r;
+00182                 r.Result = NULL;
+00183                 r.ResultState = k;*/
+00184                 return r;
+00185         }
+

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

00323         {
+00324                 IMessageBase::save(os);
+00325         }
+

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

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

00264         {
+00265 #ifdef NL_DEBUG
+00266                 if ( index >= size() )
+00267                 {
+00268                         throw NLAIE::CExceptionIndexError();
+00269                 }
+00270 #endif
+00271                 CVectorGroupType *a = (CVectorGroupType *)getMessageGroup();
+00272                 IObjectIA *b = (IObjectIA *)(*a)[ index ];
+00273                 a->setObject(index, op);
+00274                 if(op != b) b->release();
+00275                 else return true;
+00276                 return false;
+00277         }
+

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

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


IObjectIA member class.
virtual sint32	getMethodIndexSize () const
virtual const IObjectIA *	getStaticMember (sint32) const
virtual sint32	getStaticMemberIndex (const IVarName &) const
virtual sint32	getStaticMemberSize () const
virtual sint32	isClassInheritedFrom (const IVarName &) const
virtual TQueue	isMember (const IVarName , const IVarName , const IObjectIA &) const
virtual const CProcessResult &	run ()
virtual IObjectIA::CProcessResult	runMethodeMember (sint32 index, IObjectIA *)
virtual IObjectIA::CProcessResult	runMethodeMember (sint32, sint32, IObjectIA *)
virtual bool	setStaticMember (sint32, IObjectIA *)
[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 &)
	COnChangeMsg (IBasicAgent *)
	COnChangeMsg (NLAISCRIPT::CMessageClass *b=NULL)
	COnChangeMsg (std::list< IObjectIA * > &, NLAISCRIPT::CMessageClass *)
	COnChangeMsg (const COnChangeMsg &)
sint32	decRef ()
	Decrement the reference of an object.
virtual sint32	getBaseMethodCount () const
	Return the nomber of internal C++ hard coded method that the class can process.
const NLAISCRIPT::CMessageClass *	getCreatorClass () const
virtual const std::string	getInfo ()
const IBaseGroupType *	getMessageGroup () const
NLAISCRIPT::IOpCode *	getMethode (sint32 index)
	get the closure correspondent of the method indexed by index.
NLAISCRIPT::IOpCode *	getMethode (sint32 inheritance, sint32 index)
	get the closure correspondent of the method indexed by index in the base class inheritance.
virtual std::string	getMethodeMemberDebugString (sint32, sint32) const
virtual IObjetOp *	getNeg () const
const TPerformatif &	getPerformatif () const
const sint32 &	getRef () const
	get the refence count.
const IObjectIA *	getStaticMember (const IVarName &compName) const
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	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 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)
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 const CProcessResult &	runStep ()
bool	senderIsProtected () const
virtual CProcessResult	sendMessage (const IVarName &, IObjectIA *)
virtual CProcessResult	sendMessage (IObjectIA *)
virtual void	serial (NLMISC::IStream &f) throw (NLMISC::EStream)
virtual void	setAgentManager (IAgentManager *)
void	setMessageGroup (IBaseGroupType *g)
void	setPerformatif (TPerformatif p)
bool	setStaticMember (const IVarName &compName, IObjectIA *change)
void	unprotectSender ()
	~COnChangeMsg ()
NLAIC::IBasicInterface member class.
virtual const NLAIC::IBasicType *	clone () const
void	getDebugString (std::string &t) const
const NLAIC::CIdentType &	getType () const
virtual const NLAIC::IBasicType *	newInstance () const
Static Public Attributes
const NLAIC::CIdentType	IdMessageScript
const NLAIC::CIdentType	IdOnChangeMsg
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
NLAISCRIPT::CMessageClass *	_MessageClass

NLAIAGENT::COnChangeMsg Class Reference

Detailed Description

IObjectIA member class.

[NOHEADER]

Public Types

Public Member Functions

Static Public Attributes

Protected Attributes

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Field Documentation