NeL: NLAIAGENT::CPExec class Reference

00047                                     {
00048                         TConst, 
00049                         TLastM 
00050                 };

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

00060                         :IPerformative(IMessageBase::PExec)
00061                 {
00062                 }

00305                 {
00306                         _Value += value;
00307                         chekBorn();
00308                 }

00351         {
00352                 return TQueue();
00353         }

00067                 {
00068                         NLAIC::IBasicInterface *m = new CPExec();       
00069                         return m;
00070                 }

00094                 {
00095                         return --_Ref;
00096                 }

00323                 {
00324                         _Value /= value;
00325                         chekBorn();
00326                 }

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

00373                 {
00374 
00375                         text += NLAIC::stringGetBuild("%d",getValue());
00376                 }

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

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         }

00038         {
00039                 return IObjetOp::getMethodIndexSize() + TLastM;
00040         }

00084                 {
00085                         return "Exec";
00086                 }

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

00355                 {
00356                         return (double)_Value;
00357                 }

00100                 {
00101                         return _Ref;
00102                 }

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         }

00078                 {
00079                         return IdPExec;
00080                 }

00175                 {
00176                         return _Value;
00177                 }

00081                 {
00082                         _Ref ++;
00083                 }

00117         {
00118                 
00119         }

00063         {
00064                 return -1;
00065         }

00165                 {                       
00166                         return !(*(IObjectIA *)this == (IObjetOp &)a);
00167                 }

00357         {
00358                 return true;
00359         }

00043         {
00044                 TQueue a;
00045                 NLAISCRIPT::CParam methodParam;
00046                 
00047                 if(className == NULL)
00048                 {
00049                         for(int i = 0; i < TLastM; i++)
00050                         {
00051                                 if(*methodName == INombreDefine::StaticMethod[i].MethodName)
00052                                 {                                       
00053                                         CObjectType *c = new CObjectType(new NLAIC::CIdentType(NLAIC::CIdentType::VoidType));                                   
00054                                         a.push(CIdMethod(INombreDefine::StaticMethod[i].Index + IObjetOp::getMethodIndexSize(),0.0,NULL,c));                                    
00055                                         break;
00056                                 }
00057                         }
00058                 }
00059                 return a;
00060         }

00170                 {
00171                         return _Value != (tNombre)0;
00172                 }

00158                 {                               
00159                         // TODO
00160                         is.serial( _Value );                    
00161 
00162                 }

00317                 {
00318                         _Value *= value;
00319                         chekBorn();
00320                 }

00351                 {
00352                         _Value = -_Value;
00353                         chekBorn();
00354                         return *this;
00355                 }

00073                 {
00074                         return clone();
00075                 }

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

00237                 {
00238                         IObjetOp *o = (IObjetOp *)clone();                      
00239                         *o *= a;
00240                         return o;
00241                 }

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

00209                 {
00210                         tNombre v = (tNombre)((const INombreDefine &)a).getNumber();
00211                         mulValue(v);
00212                         return *this;
00213                 }

00280                 {                       
00281                         NLAILOGIC::CBoolType *x = new NLAILOGIC::CBoolType(_Value == (tNombre)0);                       
00282                         return x;
00283                 }

00286                 {
00287                         tNombre v = (tNombre)((const INombreDefine &)a).getNumber();
00288                         NLAILOGIC::CBoolType *x = new NLAILOGIC::CBoolType(_Value != v);
00289                         return x;
00290                 }

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

00223                 {
00224                         IObjetOp *o = (IObjetOp *)clone();                      
00225                         *o += a;
00226                         return o;
00227                 }

00174                 {
00175                         return *this += *a;
00176                 }

00193                 {
00194                         tNombre v = (tNombre)((const INombreDefine &)a).getNumber();
00195                         addValue(v);
00196                         return *this;
00197                 }

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

00230                 {
00231                         IObjetOp *o = (IObjetOp *)clone();                      
00232                         *o -= a;
00233                         return o;
00234                 }

00178                 {
00179                         return *this -= *a;
00180 
00181                 }

00200                 {
00201                         tNombre v = (tNombre)((const INombreDefine &)a).getNumber();
00202                         subValue(v);
00203                         return *this;
00204                 }

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

00244                 {
00245                         IObjetOp *o = (IObjetOp *)clone();                      
00246                         *o /= a;
00247                         return o;
00248                 }

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

00216                 {
00217                         tNombre v = (tNombre)((const INombreDefine &)a).getNumber();
00218                         divValue(v);
00219                         return *this;
00220                 }

00252                 {
00253                         tNombre v = (tNombre)((const INombreDefine &)a).getNumber();
00254                         NLAILOGIC::CBoolType *x = new NLAILOGIC::CBoolType(_Value < v);                 
00255                         return x;
00256                 }

00266                 {
00267                         tNombre v = (tNombre)((const INombre &)a).getNumber();
00268                         NLAILOGIC::CBoolType *x = new NLAILOGIC::CBoolType(_Value <= v);                        
00269                         return x;
00270                 }

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

00293                 {
00294                         tNombre v = (tNombre)((const INombreDefine &)a).getNumber();
00295                         NLAILOGIC::CBoolType *x = new NLAILOGIC::CBoolType(_Value == v);
00296                         return x;
00297                 }

00259                 {
00260                         tNombre v = (tNombre)((const INombreDefine &)a).getNumber();
00261                         NLAILOGIC::CBoolType *x = new NLAILOGIC::CBoolType(_Value > v);                 
00262                         return x;
00263                 }

00273                 {
00274                         tNombre v = (tNombre)((const INombre &)a).getNumber();
00275                         NLAILOGIC::CBoolType *x = new NLAILOGIC::CBoolType(_Value >= v);                        
00276                         return x;
00277                 }

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

00077         {
00078                 return IObjectIA::ProcessRun;
00079         }

00134                 {
00135                         IBaseGroupType *param = (IBaseGroupType *)p;
00136 
00137                         switch(index - IObjetOp::getMethodIndexSize())
00138                         {
00139                         case INombreDefine::TConst:
00140                                 {                                       
00141                                         _Value = (tNombre )((INombreDefine *)param->get())->getNumber();
00142                                         return IObjectIA::CProcessResult();             
00143                                 }
00144                         }
00145 
00146                         return IObjectIA::CProcessResult();
00147                 }

00130                 {
00131                         return IObjectIA::CProcessResult();
00132                 }

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         }

00151                 {       
00152                         tNombre v = _Value;
00153                         // TODO
00154                         os.serial( v );
00155                 }

00335         {
00336                 std::string text;
00337                 text = NLAIC::stringGetBuild("method 'sendMessage(%s,const IObjectIA &)' '%s' interface",name.getString(), (const char *)getType());
00338                 throw NLAIE::CExceptionNotImplemented(text.c_str());
00339                 return CProcessResult();
00340         }

00343         {
00344                 std::string text;
00345                 text = NLAIC::stringGetBuild("method 'sendMessage(const IObjectIA &)' '%s' interface", (const char *)getType());
00346                 throw NLAIE::CExceptionNotImplemented(text.c_str());
00347                 return CProcessResult();
00348         }

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

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                 }

00180                 {
00181                         _Value = value;
00182                 }

00311                 {
00312                         _Value -= value;
00313                         chekBorn();
00314                 }

 NLAIC::CIdentType( "Exec", 
                NLAIC::CSelfClassFactory((const NLAIC::IBasicInterface &)CPExec()), 
                NLAIC::CTypeOfObject::tPerformative,
                NLAIC::CTypeOfOperator(NLAIC::CTypeOfOperator::opNone) )

 
        {
                INombreDefine::CMethodCall(_CONSTRUCTOR_,TConst)                
        }


Public Types
enum	TMethodNumDef { TConst, TLastM }
	This enum define ident for hard coded method that we have to import its under the script. More...
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 }
Public Member Functions
virtual TQueue	canProcessMessage (const IVarName &)
	CPExec ()
sint32	decRef ()
	Decrement the reference of an object.
virtual void	getDebugString (std::string &text) const
virtual const std::string	getInfo ()
virtual std::string	getMethodeMemberDebugString (sint32, sint32) const
virtual const char *	getName () const
virtual IObjetOp *	getNeg () const
virtual double	getNumber () 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
sint32	getValue () 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	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 bool	isTrue () const
	throw (NLAIE::CExceptionNotImplemented)
virtual void	load (NLMISC::IStream &is)
virtual IObjetOp &	neg ()
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp *	operator * (IObjetOp *a)
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp *	operator * (const IObjetOp &a)
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp &	operator = (IObjetOp a)
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp &	operator *= (const IObjetOp &a)
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp *	operator! () const
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp *	operator!= (IObjetOp &a) const
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp *	operator+ (IObjetOp *a)
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp *	operator+ (const IObjetOp &a)
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp &	operator+= (IObjetOp *a)
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp &	operator+= (const IObjetOp &a)
	add the operater by anather.
virtual IObjetOp *	operator- (IObjetOp *a)
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp *	operator- (const IObjetOp &a)
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp &	operator-= (IObjetOp *a)
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp &	operator-= (const IObjetOp &a)
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp *	operator/ (IObjetOp *a)
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp *	operator/ (const IObjetOp &a)
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp &	operator/= (IObjetOp *a)
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp &	operator/= (const IObjetOp &a)
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp *	operator< (IObjetOp &a) const
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp *	operator<= (IObjetOp &a) const
	throw (NLAIE::CExceptionNotImplemented)
bool	operator== (const IBasicObjectIA &classType) const
virtual IObjetOp *	operator== (IObjetOp &a) const
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp *	operator> (IObjetOp &a) const
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp *	operator>= (IObjetOp &a) const
	throw (NLAIE::CExceptionNotImplemented)
virtual void	release ()
	Release allow to release the pointer. The last release when the _Ref is nul delete the object.
virtual const CProcessResult &	run ()
virtual CProcessResult	runMethodeMember (sint32 index, IObjectIA *p)
virtual CProcessResult	runMethodeMember (sint32, sint32, IObjectIA *)
virtual const CProcessResult &	runStep ()
virtual void	save (NLMISC::IStream &os)
virtual CProcessResult	sendMessage (const IVarName &, IObjectIA *)
virtual CProcessResult	sendMessage (IObjectIA *)
virtual void	serial (NLMISC::IStream &f) throw (NLMISC::EStream)
virtual bool	setStaticMember (sint32, IObjectIA *)
bool	setStaticMember (const IVarName &compName, IObjectIA *change)
void	setValue (sint32value)
Base class member method.
virtual const NLAIC::IBasicType *	clone () const
virtual const NLAIC::CIdentType &	getType () const
virtual const NLAIC::IBasicType *	newInstance () const
Static Public Attributes
const NLAIC::CIdentType	IdIntegerType
const NLAIC::CIdentType	IdPExec
TProcessStatement	ProcessBuzzy = processBuzzy
TProcessStatement	ProcessEnd = processEnd
TProcessStatement	ProcessError = processError
TProcessStatement	ProcessIdle = processIdle
TProcessStatement	ProcessLocked = processLocked
CProcessResult	ProcessNotComplit = IObjectIA::CProcessResult(processNotComplete)
CProcessResult	ProcessRun = IObjectIA::CProcessResult()
CMethodCall	StaticMethod []
	This variable its used to store method import characteristic.
Protected Member Functions
void	addValue (sint32value)
virtual void	chekBorn ()
void	divValue (sint32value)
void	mulValue (sint32value)
void	subValue (sint32value)
Protected Attributes
sint32	_Value

NLAIAGENT::CPExec Class Reference

Detailed Description

Public Types

Public Member Functions

Static Public Attributes

Protected Member Functions

Protected Attributes

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Field Documentation