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

00789                                                   : _Vector(i)
00790         {
00791         }

00798         {
00799                 _Vector = g._Vector;
00800                 TVectorType::const_iterator i = _Vector.begin();
00801                 while(i != _Vector.end())
00802                 {
00803                         ((IObjectIA *)(*i++))->incRef();
00804                 }
00805         }

01132         {                       
01133                 clear();
01134         }

00351         {
00352                 return TQueue();
00353         }

01077         {
01078                 while(_Vector.size())
01079                 {
01080                         NLAIC::IBasicInterface * o = (NLAIC::IBasicInterface *)_Vector.front();                 
01081                         o->release();
01082                         _Vector.erase( _Vector.begin() );
01083                 }
01084         }

01019         {
01020                 NLAIC::IBasicInterface *m = new CVectorGroupType(*this);
01021                 return m;
01022         }

00850         {
00851                 _Vector.push_back((const IObjectIA *)o.clone());
00852         }

00094                 {
00095                         return --_Ref;
00096                 }

00995         {                       
00996                 std::list<const IObjectIA *>::iterator i = l.begin();
00997                 while(i != l.end())
00998                 {
00999                         erase(*i++);                                                            
01000                 }
01001         }

00979         {       
00980                 TVectorType::iterator i = _Vector.begin();
00981                 while(i != _Vector.end())
00982                 {
00983                         TVectorType::iterator j = i++;
00984                         if ( *(*j) == obj )
00985                         {
00986                                 IObjectIA *o = (IObjectIA *)*j;
00987                                 _Vector.erase(j);
00988                                 o->release();
00989                                 return;
00990                         }                               
00991                 }
00992         }

00963         {       
00964                 TVectorType::iterator i = _Vector.begin();
00965                 while(i != _Vector.end())
00966                 {
00967                         TVectorType::iterator j = i++;
00968                         if( *j == o)
00969                         {
00970                                 IObjectIA *o = (IObjectIA *)*j;
00971                                 _Vector.erase(j);
00972                                 o->release();
00973                                 return;
00974                         }                               
00975                 }
00976         }

00947         {                       
00948                 TVectorType::iterator i = _Vector.begin();
00949                 while(i != _Vector.end())
00950                 {
00951                         TVectorType::iterator j = i++;
00952                         IObjectIA *o= (IObjectIA *)*j;
00953                         if( *o == obj)
00954                         {                                       
00955                                 _Vector.erase(j);
00956                                 o->release();
00957                                 return;
00958                         }
00959                 }
00960         }

00936         {                       
00937                 TVectorType::const_iterator i = _Vector.begin();
00938                 while(i != _Vector.end())
00939                 {
00940                         const IObjectIA *o = *i++;
00941                         if( *o == obj) return o;
00942                 }
00943                 return NULL;
00944         }

00884         {
00885                 TVectorType l;                  
00886                 TVectorType::const_iterator i = _Vector.begin();
00887                 while(i != _Vector.end())
00888                 {
00889                         const IObjectIA *o = *i++;
00890                         if( *o == obj) 
00891                                 l.push_back( o );
00892                 }
00893                 return l;
00894         }

00862         {
00863                 return _Vector.back();                  
00864         }

00926         {
00927                 return _Vector.begin();
00928         }

00916         {
00917                 return _Vector.begin();
00918         }

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

00768                 {
00769                         return CConstIteratorContener((IBasicIterator *)(new CConstVectorIterator(_Vector)));
00770                 }

00808         {               
00809                 
00810                 if(_Vector.size())
00811                 {                       
00812                         text += "[";
00813                         std::vector<const IObjectIA *>::const_iterator i = _Vector.begin();
00814                         while(i != _Vector.end())
00815                         {
00816                                 std::string temp;
00817                                 const IObjectIA *o = *i++;
00818                                 o->getDebugString(temp);                                
00819                                 text += temp;
00820                                 if(i != _Vector.end()) text += " ";
00821                         }
00822                         text += "]";
00823 
00824                 }
00825                 else
00826                 {
00827                         text += NLAIC::stringGetBuild("CVectorGroupType<%04x>: <empty>",this);
00828                 }               
00829         }

00931         {
00932                 return _Vector.end();
00933         }

00921         {
00922                 return _Vector.end();
00923         }

00874         {
00875                 return _Vector.front();                 
00876         }

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

00763                 {
00764                         return CIteratorContener(new CVectorIterator(_Vector));
00765                 }

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         }

01111         {
01112                 return IBaseGroupType::getMethodIndexSize() + 1;
01113         }

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

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         }

00769         {               
00770                 return IdVectorGroupType;
00771         }

00784         {
00785                 return _Vector;
00786         }

00081                 {
00082                         _Ref ++;
00083                 }

00117         {
00118                 
00119         }

00257         {
00258                 return -1;
00259         }

01004         {
01005                 const CVectorGroupType &b = (const CVectorGroupType &)a;                        
01006                 if(size() != b.size()) return false;
01007 
01008                 TVectorType::const_iterator i = _Vector.begin();
01009                 TVectorType::const_iterator j = _Vector.begin();
01010                 
01011                 while(i != _Vector.end())
01012                 {
01013                         if(!(*i++)->isEqual(*(*j++))) return false;
01014                 }
01015                 return true;
01016         }

00357         {
00358                 return true;
00359         }

01087         {
01088                 TQueue a;
01089                 NLAISCRIPT::CParam methodParam;
01090                 NLAISCRIPT::CParam &param = (NLAISCRIPT::CParam &)p;
01091                 
01092                 if(param.size() != 1) return IBaseGroupType::isMember(className,methodName,p);
01093 
01094                 if(className == NULL)
01095                 {                       
01096                         if(*methodName == IBaseGroupType::_Method[0].MethodName)
01097                         {                               
01098                                 CObjectType *c = new CObjectType(new NLAIC::CIdentType(NLAIC::CIdentType::VoidType));
01099                                 a.push(CIdMethod(_Const + IBaseGroupType::getMethodIndexSize(),0.0,NULL,c));                            
01100                         }
01101                         else
01102                         {
01103                                 return IBaseGroupType::isMember(className,methodName,p);
01104                         }
01105                         
01106                 }
01107                 return a;
01108         }

00262         {
00263                 return IObjetOp::isTrue();
00264         }

01056         {                       
01057                 sint32 i;
01058                 while(_Vector.size())
01059                 {
01060                         NLAIC::IBasicInterface * o = (NLAIC::IBasicInterface *)_Vector.front();
01061                         o->release();
01062                         _Vector.erase( _Vector.begin() );
01063                 }
01064                 is.serial( i );
01065                 NLAIC::CIdentTypeAlloc id;
01066                 while(i--)
01067                 {                               
01068                         is.serial( id );
01069                         NLAIC::IBasicInterface *o = (NLAIC::IBasicInterface *)id.allocClass();                          
01070                         o->load(is);
01071                         _Vector.push_back((const IObjectIA *)o);
01072                                 
01073                 }                       
01074         }

01044         {
01045                 TVectorType::iterator i = _Vector.begin();
01046                 while(i != _Vector.end())
01047                 {
01048                         const NLAIC::CTypeOfOperator &op = (const NLAIC::CTypeOfOperator &)(*i)->getType();
01049                         if((uint32)(op & NLAIC::CTypeOfOperator::opNeg)) ((IObjetOp *)(*i))->neg();
01050                         i++;
01051                 }
01052                 return *this;   
01053         }

01025         {
01026                 NLAIC::IBasicInterface *m = new CVectorGroupType();
01027                 return m;
01028         }

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                 }

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                 }

00684         {
00685                 CVectorGroupType *o = new CVectorGroupType();
00686                 TVectorType::const_iterator i = _Vector.begin();
00687                 while(i != _Vector.end())
00688                 {
00689                         o->_Vector.push_back(*i);
00690                         ((IObjetOp*)(*i))->incRef();
00691                         i ++;
00692                 }
00693                 
00694                 *o += a;
00695                 a->incRef();
00696                 return o;
00697         }

00715         {
00716                 CVectorGroupType *o = new CVectorGroupType();
00717                 TVectorType::const_iterator i = _Vector.begin();
00718                 while(i != _Vector.end())
00719                 {
00720                         o->_Vector.push_back(*i);
00721                         ((IObjetOp*)(*i))->incRef();
00722                         i ++;
00723                 }
00724                 
00725                 *o += a;
00726                 
00727                 return o;
00728         }

00069         {
00070                 cpy(a);
00071                 return *this;
00072         }

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

00699         {
00700                 CVectorGroupType *o = new CVectorGroupType();
00701                 TVectorType::const_iterator i = _Vector.begin();
00702                 while(i != _Vector.end())
00703                 {
00704                         o->_Vector.push_back(*i);
00705                         ((IObjetOp*)(*i))->incRef();
00706                         i ++;
00707                 }
00708                 
00709                 *o -= a;                
00710                 a->release();
00711                 return o;
00712         }

00730         {
00731                 CVectorGroupType *o = new CVectorGroupType();
00732                 TVectorType::const_iterator i = _Vector.begin();
00733                 while(i != _Vector.end())
00734                 {
00735                         o->_Vector.push_back(*i);
00736                         ((IObjetOp*)(*i))->incRef();
00737                         i ++;
00738                 }
00739                 
00740                 *o -= a;                
00741                 return o;
00742         }

00075         {
00076                 erase(a);
00077                 return *this;
00078         }

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

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                 }

00752         {               
00753                 clear();
00754                 if((uint)(((const NLAIC::CTypeOfObject &)a.getType()) & NLAIC::CTypeOfObject::tList))
00755                 {
00756                         const CVectorGroupType &g= (const CVectorGroupType &)a;
00757                         TVectorType::const_iterator i = g._Vector.begin();
00758                         while(i != g._Vector.end())
00759                         {
00760                                 _Vector.push_back((const IObjectIA *)(*i++)->clone());
00761                         }
00762                 }       
00763                 else 
00764                         _Vector.push_back((const IObjectIA *)a.clone());
00765                 return *this;
00766         }

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                 }

00897         {
00898 #ifdef _DEGUG
00899                 if ( index >= (sint32) _Vector.size() )
00900                 {
00901                         //TODO: throw Exc::CExceptionIndexError
00902                 }
00903 #endif
00904 
00905                 return _Vector[ index ];
00906         }

00855         {
00856                 const IObjectIA *Obj = _Vector.back();
00857                 _Vector.erase( _Vector.end() );
00858                 return Obj;
00859         }

00867         {
00868                 const IObjectIA *Obj = _Vector.front();
00869                 _Vector.erase( _Vector.begin() );
00870                 return Obj;
00871         }

00834         {
00835                 _Vector.push_back(o);
00836         }

00839         {
00840                 _Vector.push_back(o);
00841                 for(sint32 i = (sint32)_Vector.back() - 2; i == 0; i -- )
00842                 {                       
00843                         _Vector[i + 1] = _Vector[i];
00844                 }
00845                 _Vector[0] = o;
00846 
00847         }

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

00774         {
00775                 TVectorType::iterator i = _Vector.begin();
00776                 while(i != _Vector.end())
00777                 {
00778                         ((IObjectIA *)(*i++))->run();
00779                 }
00780                 return IObjectIA::ProcessRun; 
00781         }

01120         {
01121                 sint32 i= index - IBaseGroupType::getMethodIndexSize();
01122                 if(i == _Const)
01123                 {
01124                         IBaseGroupType *param = (IBaseGroupType *)p;
01125                         const DigitalType *f = (const DigitalType *)param->get();
01126                         _Vector.reserve((int)f->getValue());
01127                 }
01128                 return IBaseGroupType::runMethodeMember(index,p);
01129         }

01116         {
01117                 return IObjectIA::CProcessResult();
01118         }

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         }

01031         {       
01032                 sint32 size = _Vector.size();
01033                 os.serial( size );
01034                 std::vector<const IObjectIA *>::const_iterator i = _Vector.begin();
01035                 while(i != _Vector.end())
01036                 {
01037                         IObjectIA *o= (IObjectIA *)*i++;
01038                         os.serial( (NLAIC::CIdentType &) o->getType() );
01039                         o->save(os);
01040                 }                       
01041         }

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                 }

00909         {
00910                 if((IObjectIA *)_Vector[ index ] != NULL) ((IObjectIA *)_Vector[ index ])->release();
00911                 _Vector[ index ] = o;
00912         }

00773                 {
00774                         _Vector[i] = a;
00775                 }

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                 }

00879         {
00880                 return _Vector.size();
00881         }

 
        {
                IBaseGroupType::CMethodCall(_CONSTRUCTOR_,_Const),
                IBaseGroupType::CMethodCall("Push",_Push),
                IBaseGroupType::CMethodCall("PushFront",_PushFront),
                IBaseGroupType::CMethodCall("Pop",_Pop),
                IBaseGroupType::CMethodCall("PopFront",_PopFront),
                IBaseGroupType::CMethodCall("Back",_Back),
                IBaseGroupType::CMethodCall("Front",_Front),            
                IBaseGroupType::CMethodCall("Get",_Get),
                IBaseGroupType::CMethodCall("Set",_Set),
                IBaseGroupType::CMethodCall("Size",_Size)
        }

NLAIAGENT::CVectorGroupType Class Reference

Detailed Description

Public Types

Public Member Functions

Static Public Attributes

Protected Member Functions

Private Attributes

Member Typedef Documentation

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Field Documentation


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 }
typedef std::vector< const IObjectIA * >	TVectorType
Public Member Functions
virtual TQueue	canProcessMessage (const IVarName &)
void	clear ()
	Clear the list.
virtual const NLAIC::IBasicType *	clone () const
void	cpy (const IObjectIA &o)
	Push an IObjectIA back using the clone method.
	CVectorGroupType (const CVectorGroupType &g)
	CVectorGroupType ()
	CVectorGroupType (sint32)
	Construct a vector with n uninitialize momory unite. Programmer must initialize the vector list after.
IObjetOp *	CVectorGroupType::operator! () const
sint32	decRef ()
	Decrement the reference of an object.
void	erase (std::list< const IObjectIA * > &l)
	Erase all element contain in the list.
void	erase (const IObjectIA &obj)
	Erase the first element find equal at the const IObjectIA& on argument.
void	erase (const IObjectIA *o)
	Erase the element how have the same pointer memory as the argument const IObjectIA *.
void	eraseAll (const IObjectIA &obj)
	Erase all element find equal at the const IObjectIA & on argument.
const IObjectIA *	find (const IObjectIA &obj) const
	Find an element on the list the operator == is use.
TVectorType	findList (const IObjectIA &obj) const
const IObjectIA *	get () const
	return the back IObjectIA.
TVectorType::iterator	getBegin ()
TVectorType::const_iterator	getBegin () const
virtual CConstIteratorContener	getConstIterator () const
	Clear the list.
virtual void	getDebugString (std::string &text) const
TVectorType::iterator	getEnd ()
TVectorType::const_iterator	getEnd () const
const IObjectIA *	getFront () const
	return the front IObjectIA.
virtual const std::string	getInfo ()
virtual CIteratorContener	getIterator ()
	Get an iterator to parse the list.
virtual std::string	getMethodeMemberDebugString (sint32, sint32) const
virtual sint32	getMethodIndexSize () const
virtual IObjetOp *	getNeg () 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 NLAIC::CIdentType &	getType () 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 TQueue	isMember (const IVarName , const IVarName , const IObjectIA &) const
virtual void	load (NLMISC::IStream &is)
virtual IObjetOp &	neg ()
	throw (NLAIE::CExceptionNotImplemented)
virtual const NLAIC::IBasicType *	newInstance () const
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 *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/= (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)
virtual const IObjectIA *	operator[] (sint32) const
	Clear the list.
const IObjectIA *	pop ()
	Pop the back IObjectIA and return it.
const IObjectIA *	popFront ()
	Pop the front IObjectIA and return it.
void	push (const IObjectIA *o)
	Push an IObjectIA back.
void	pushFront (const IObjectIA *o)
	Push an IObjectIA front.
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 *)
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 void	set (int, IObjectIA *)
	Push an IObjectIA at the position indicate by the int.
void	setObject (sint32 i, IObjectIA *a)
virtual bool	setStaticMember (sint32, IObjectIA *)
bool	setStaticMember (const IVarName &compName, IObjectIA *change)
sint32	size () const
	get the size of the list.
virtual	~CVectorGroupType ()
Some IObjetOp method definition.
virtual IObjetOp &	operator+= (IObjetOp *a)
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp &	operator-= (IObjetOp *a)
	throw (NLAIE::CExceptionNotImplemented)
Some IObjetOp method definition.
virtual IObjetOp &	operator+= (IObjetOp *a)
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp &	operator-= (IObjetOp *a)
	throw (NLAIE::CExceptionNotImplemented)
Some IObjetOp method definition.
virtual IObjetOp &	operator+= (IObjetOp *a)
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp &	operator-= (IObjetOp *a)
	throw (NLAIE::CExceptionNotImplemented)
Some IObjetOp method definition.
virtual IObjetOp &	operator+= (IObjetOp *a)
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp &	operator-= (IObjetOp *a)
	throw (NLAIE::CExceptionNotImplemented)
Some IObjetOp method definition.
virtual IObjetOp &	operator+= (IObjetOp *a)
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp &	operator-= (IObjetOp *a)
	throw (NLAIE::CExceptionNotImplemented)
Some IObjetOp method definition.
virtual bool	isTrue () const
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp *	operator! () const=0
	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)
Some IObjetOp method definition.
virtual bool	isTrue () const
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp *	operator! () const=0
	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)
Some IObjectIA method definition.
virtual sint32	isClassInheritedFrom (const IVarName &) const
Some IObjetOp method definition.
virtual IObjetOp &	operator+= (IObjetOp *a)
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp &	operator-= (IObjetOp *a)
	throw (NLAIE::CExceptionNotImplemented)
Some IObjetOp method definition.
virtual IObjetOp &	operator+= (IObjetOp *a)
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp &	operator-= (IObjetOp *a)
	throw (NLAIE::CExceptionNotImplemented)
Some IObjectIA method definition.
virtual sint32	isClassInheritedFrom (const IVarName &) const
Some IObjetOp method definition.
virtual IObjetOp &	operator+= (IObjetOp *a)
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp &	operator-= (IObjetOp *a)
	throw (NLAIE::CExceptionNotImplemented)
Some IObjetOp method definition.
virtual IObjetOp &	operator+= (IObjetOp *a)
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp &	operator-= (IObjetOp *a)
	throw (NLAIE::CExceptionNotImplemented)
Some IObjetOp method definition.
virtual IObjetOp &	operator+= (IObjetOp *a)
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp &	operator-= (IObjetOp *a)
	throw (NLAIE::CExceptionNotImplemented)
Some IObjetOp method definition.
virtual bool	isTrue () const
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp *	operator! () const=0
	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)
Some IObjetOp method definition.
virtual IObjetOp &	operator+= (IObjetOp *a)
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp &	operator-= (IObjetOp *a)
	throw (NLAIE::CExceptionNotImplemented)
Some IObjetOp method definition.
virtual IObjetOp &	operator+= (IObjetOp *a)
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp &	operator-= (IObjetOp *a)
	throw (NLAIE::CExceptionNotImplemented)
Some IObjectIA method definition.
virtual sint32	isClassInheritedFrom (const IVarName &) const
Some IObjetOp method definition.
virtual IObjetOp &	operator+= (IObjetOp *a)
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp &	operator-= (IObjetOp *a)
	throw (NLAIE::CExceptionNotImplemented)
Some IObjectIA method definition.
virtual sint32	isClassInheritedFrom (const IVarName &) const
Some IObjetOp method definition.
virtual bool	isTrue () const
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp *	operator! () const=0
	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)
Some IObjetOp method definition.
virtual bool	isTrue () const
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp *	operator! () const=0
	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)
Some IObjectIA method definition.
virtual sint32	isClassInheritedFrom (const IVarName &) const
Some IObjetOp method definition.
virtual IObjetOp &	operator+= (IObjetOp *a)
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp &	operator-= (IObjetOp *a)
	throw (NLAIE::CExceptionNotImplemented)
Some IObjectIA method definition.
virtual sint32	isClassInheritedFrom (const IVarName &) const
Some IObjetOp method definition.
virtual IObjetOp &	operator+= (IObjetOp *a)
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp &	operator-= (IObjetOp *a)
	throw (NLAIE::CExceptionNotImplemented)
Some IObjectIA method definition.
virtual sint32	isClassInheritedFrom (const IVarName &) const
Some IObjetOp method definition.
virtual IObjetOp &	operator+= (IObjetOp *a)
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp &	operator-= (IObjetOp *a)
	throw (NLAIE::CExceptionNotImplemented)
Static Public Attributes
CMethodCall	_Method []
const NLAIC::CIdentType	IdVectorGroupType
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 Member Functions
TVectorType &	getVector ()
Private Attributes
TVectorType	_Vector
	std::vector for store IObjectIA object.