nevrax.org : docs

00001 
00007 /* Copyright, 2000 Nevrax Ltd.
00008  *
00009  * This file is part of NEVRAX NEL.
00010  * NEVRAX NEL is free software; you can redistribute it and/or modify
00011  * it under the terms of the GNU General Public License as published by
00012  * the Free Software Foundation; either version 2, or (at your option)
00013  * any later version.
00014 
00015  * NEVRAX NEL is distributed in the hope that it will be useful, but
00016  * WITHOUT ANY WARRANTY; without even the implied warranty of
00017  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
00018  * General Public License for more details.
00019 
00020  * You should have received a copy of the GNU General Public License
00021  * along with NEVRAX NEL; see the file COPYING. If not, write to the
00022  * Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
00023  * MA 02111-1307, USA.
00024  */
00025 #ifndef NL_AGENT_OBJECT_DEF_H
00026 #define NL_AGENT_OBJECT_DEF_H
00027 
00028 
00029 #include "nel/ai/agent/agent_string.h"
00030 #include "nel/ai/agent/agent_operator.h"
00031 
00032 
00033 namespace NLAIAGENT
00034 {                       
00035 
00043         class CStringType: public IObjetOp
00044         {
00045         private:                
00046                 IVarName *_Str;                                 
00047 
00048         public:
00049                 static const NLAIC::CIdentType IdStringType;
00050         public:
00051                 CStringType(const std::string &str): _Str(new CStringVarName(str.c_str()))
00052                 {
00053                 }
00054 
00055                 CStringType(const IVarName &str): _Str((IVarName *)str.clone())
00056                 {                       
00057                 }
00058 
00059                 CStringType(const CStringType &a): _Str((IVarName *)a._Str->clone())
00060                 {                       
00061                 }               
00062 
00063                 CStringType(NLMISC::IStream &is)
00064                 {
00065                         load(is);
00066                 }
00067                 
00068                 virtual const NLAIC::IBasicType *clone() const
00069                 {
00070                         NLAIC::IBasicInterface *m = new CStringType(*this);
00071                         return m;
00072                 }               
00073 
00074                 virtual const NLAIC::IBasicType *newInstance() const
00075                 {
00076                         return clone();
00077                 }
00078                 
00079                 virtual const NLAIC::CIdentType &getType() const;               
00080 
00081                 virtual void save(NLMISC::IStream &os)
00082                 {                       
00083                         os.serial( (NLAIC::CIdentType &) ( _Str->getType() ) );
00084                         _Str->save(os);
00085                 }
00086 
00087                 virtual void load(NLMISC::IStream &is)
00088                 {                       
00089                         NLAIC::CIdentTypeAlloc id;
00090                         is.serial( id );
00091                         _Str->release();
00092                         _Str = (IVarName *)id.allocClass();                     
00093                         _Str->load(is);                 
00094                 }
00095 
00096 
00097                 virtual void getDebugString(std::string &text) const
00098                 {
00099                         text += NLAIC::stringGetBuild("%s",_Str->getString());
00100                 }
00101 
00102                 const IVarName & getStr() const
00103                 {
00104                         return *_Str;
00105                 }
00106 
00108 
00109                 virtual IObjetOp &operator += (const IObjetOp &a);              
00110                 virtual IObjetOp &operator -= (const IObjetOp &a);              
00111                 virtual IObjetOp *operator < (IObjetOp &a) const;
00112                 virtual IObjetOp *operator > (IObjetOp &a) const;
00113                 virtual IObjetOp *operator <= (IObjetOp &a) const;      
00114                 virtual IObjetOp *operator >= (IObjetOp &a) const;      
00115                 virtual IObjetOp *operator != (IObjetOp &a) const;
00116                 virtual IObjetOp *operator == (IObjetOp &a) const;
00118 
00119 
00120                 virtual bool operator < (const CStringType &a) const;
00121 
00122 
00123                 virtual bool isTrue() const
00124                 {
00125                         return IObjetOp::isTrue();
00126                 }
00127                 
00128                 virtual ~CStringType()
00129                 {       
00130                         _Str->release();
00131                 }       
00132                 
00133                 virtual bool isEqual(const IBasicObjectIA &a) const
00134                 {
00135                         const CStringType &t = (const CStringType &)a;
00136                         return *t._Str == *_Str;
00137                 }
00138                         
00139 
00140                 virtual const CProcessResult &run();            
00141         };
00142 
00143                 
00144 
00151         class CPairType: public IObjetOp
00152         {
00153         public:
00154                 struct CMethodCall
00155                 {
00156                         CMethodCall(const char *name, int i): MethodName (name)
00157                         {                               
00158                                 Index = i;
00159                         }
00160                         CStringVarName MethodName;
00161                         sint32 Index;
00162                 };
00163                 static CMethodCall _Method[];
00164 
00165         private:                
00166                 IObjectIA *_First;
00167                 IObjectIA *_Second;
00168 
00169         public:
00170                 static const NLAIC::CIdentType IdPaireType;
00171                 
00172         public:
00173                 CPairType(IObjectIA *first,IObjectIA *second): 
00174                   _First(first),_Second(second)
00175                 {                       
00176                 }
00177 
00178                 CPairType(const CPairType &a): _First(a._First),_Second(a._Second)
00179                 {
00180                         _First->incRef();
00181                         _Second->incRef();
00182                 }                               
00183 
00184                 virtual const NLAIC::IBasicType *clone() const
00185                 {
00186                         NLAIC::IBasicInterface *m = new CPairType(*this);
00187                         return m;
00188                 }
00189 
00190                 virtual const NLAIC::IBasicType *newInstance() const
00191                 {
00192                         return clone();
00193                 }
00194                 
00195                 virtual const NLAIC::CIdentType &getType() const
00196                 {
00197                         return IdPaireType;
00198                 }
00199                 
00200 
00201                 virtual void save(NLMISC::IStream &os)
00202                 {                                                                                               
00203                 }
00204 
00205                 virtual void load(NLMISC::IStream &is)
00206                 {                                                                       
00207                 }
00208 
00209                 virtual const CProcessResult &run()
00210                 {
00211                         return IObjectIA::ProcessRun;
00212                 }
00213 
00214                 virtual void getDebugString(std::string &text) const
00215                 {
00216                         std::string f,s;
00217 
00218                         _First->getDebugString(f);
00219                         _Second->getDebugString(s);
00220                         text += "First:<";
00221                         text += f;
00222                         text += ">";
00223                         text += "Second:<";
00224                         text += s;
00225                         text += ">";
00226                 }
00227 
00228                 virtual bool isTrue() const
00229                 {
00230                         return IObjetOp::isTrue();
00231                 }
00232                 
00233                 IObjectIA *first() const
00234                 {
00235                         return _First;
00236                 }
00237 
00238                 IObjectIA *second() const
00239                 {
00240                         return _Second;
00241                 }
00242                 
00243                 virtual ~CPairType()
00244                 {                       
00245                         _First->release();
00246                         _Second->release();
00247                 }       
00248 
00249                 virtual bool isEqual(const IBasicObjectIA &a) const
00250                 {
00251                         const CPairType &t = (const CPairType &)a;
00252                         if((t._First) == (_First)) return t._Second == _Second;
00253                         return false;
00254                 }
00255 
00256                 virtual sint32 getMethodIndexSize() const;
00257                 virtual tQueue isMember(const IVarName *,const IVarName *,const IObjectIA &) const;
00258                 virtual CProcessResult runMethodeMember(sint32, sint32, IObjectIA *);
00259                 virtual CProcessResult runMethodeMember(sint32 index,IObjectIA *);
00260         };      
00261 
00272         class IConstBasicIterator
00273         {
00274         public:
00275                 IConstBasicIterator() {}
00276                 virtual const IObjetOp* operator ++ (int) = 0;
00277                 virtual const IObjetOp* operator -- (int) = 0;
00278                 virtual operator const IObjetOp*() const = 0;           
00279                 virtual bool isInEnd() const = 0;
00280                 virtual bool isInBegin() const = 0;
00281                 virtual ~IConstBasicIterator() {}
00282         };
00283 
00284         class IBasicIterator: public IConstBasicIterator
00285         {
00286         public:
00287                 IBasicIterator() {}             
00288                 virtual void erase() = 0;               
00289                 virtual ~IBasicIterator() {}
00290         };
00291 
00299         template<class typeClass>
00300         class CTemplateIterator: public IBasicIterator
00301         {
00302         private:
00303                 typename typeClass::iterator _I;
00304                 typeClass       &_ListType;
00305                 
00306         public:
00307                 CTemplateIterator(typeClass &l):_I(l.begin()),_ListType(l)
00308                 {
00309                 }
00310                 virtual ~CTemplateIterator()
00311                 {
00312                 }
00313 
00314                 virtual const IObjetOp* operator ++ (int) 
00315                 {
00316                         return (const IObjetOp*)*_I++;
00317                 }
00318                 virtual const IObjetOp* operator -- (int)
00319                 {
00320                         return (const IObjetOp*)*_I--;
00321                 }
00322 
00323                 virtual operator const IObjetOp *() const
00324                 {
00325                         return (const IObjetOp *)*_I;
00326                 }
00327                 
00328                 virtual void erase()
00329                 {
00330                         typename typeClass::iterator temp = _I;
00331                         _I++;
00332                         _ListType.erase(temp);
00333                 }
00334 
00335                 virtual bool isInEnd() const
00336                 {                       
00337                         return _I == _ListType.end();           
00338                 }
00339 
00340                 virtual bool isInBegin() const
00341                 {
00342                         return _I == _ListType.begin();
00343                 }
00344         };
00345 
00346         template<class typeClass>
00347         class CConstTemplateIterator: public IConstBasicIterator
00348         {
00349         private:
00350                 typename typeClass::const_iterator _I;
00351                 const typeClass &_ListType;
00352                 
00353         public:
00354                 CConstTemplateIterator(const typeClass &l):_I(l.begin()),_ListType(l)
00355                 {
00356                 }
00357                 virtual ~CConstTemplateIterator()
00358                 {
00359                 }
00360 
00361                 virtual const IObjetOp* operator ++ (int) 
00362                 {
00363                         return (const IObjetOp*)*_I++;
00364                 }
00365                 virtual const IObjetOp* operator -- (int)
00366                 {
00367                         return (const IObjetOp*)*_I--;
00368                 }
00369 
00370                 virtual operator const IObjetOp *() const
00371                 {
00372                         return (const IObjetOp *)*_I;
00373                 }
00374                                 
00375                 virtual bool isInEnd() const
00376                 {                       
00377                         return _I == _ListType.end();           
00378                 }
00379 
00380                 virtual bool isInBegin() const
00381                 {
00382                         return _I == _ListType.begin();
00383                 }
00384         };
00385 
00386 
00395         class CListIterator: public CTemplateIterator<std::list<const IObjectIA *> >
00396         {
00397         public:
00398                 CListIterator(std::list<const IObjectIA *> &l): CTemplateIterator<std::list<const IObjectIA *> >(l)
00399                   {
00400                   }
00401 
00402                 virtual ~CListIterator()
00403                 {
00404                 }
00405 
00406         };
00407 
00408         class CConstListIterator: public CConstTemplateIterator<std::list<const IObjectIA *> >
00409         {
00410         public:
00411                 CConstListIterator(const std::list<const IObjectIA *> &l): CConstTemplateIterator<std::list<const IObjectIA *> >(l)
00412                 {
00413                 }
00414 
00415                 virtual ~CConstListIterator()
00416                 {
00417                 }
00418 
00419         };
00420         
00428         class CVectorIterator: public CTemplateIterator<std::vector<const IObjectIA *> >
00429         {
00430         public:
00431                 CVectorIterator(std::vector<const IObjectIA *>&l): CTemplateIterator<std::vector<const IObjectIA *> >(l)
00432                   {
00433                   }
00434 
00435                 virtual ~CVectorIterator()
00436                 {
00437                 }
00438 
00439         };
00440 
00441         class CConstVectorIterator: public CConstTemplateIterator<std::vector<const IObjectIA *> >
00442         {
00443         public:
00444                 CConstVectorIterator(const std::vector<const IObjectIA *>&l): CConstTemplateIterator<std::vector<const IObjectIA *> >(l)
00445                 {
00446                 }
00447 
00448                 virtual ~CConstVectorIterator()
00449                 {
00450                 }
00451 
00452         };
00453 
00462         class CConstIteratorContener: public IConstBasicIterator
00463         {
00464         protected:
00465                 IBasicIterator *_I;
00466         public:
00467                 CConstIteratorContener(const CConstIteratorContener &i):_I(i._I)
00468                 {
00469                 }
00470 
00471                 CConstIteratorContener(IBasicIterator *i):_I(i)
00472                 {
00473                 }
00474 
00475                 virtual ~CConstIteratorContener()
00476                 {
00477                         delete _I;
00478                 }
00479 
00480                 virtual const IObjetOp*operator ++ (int) 
00481                 {
00482                         const IObjetOp *a = (*_I)++;                    
00483                         return a;
00484                 }
00485                 virtual const IObjetOp*operator -- (int)
00486                 {
00487                         const IObjetOp *a = (*_I) --;                   
00488                         return a;
00489                 }               
00490                 virtual operator const IObjetOp*() const
00491                 {
00492                         return (const IObjetOp *)*_I;
00493                 }               
00494                 
00495                 virtual bool isInEnd() const 
00496                 {                       
00497                         return _I->isInEnd();
00498                 }
00499                 virtual bool isInBegin() const
00500                 {
00501                         return _I->isInBegin();
00502                 }
00503         };
00504 
00505         class CIteratorContener: public CConstIteratorContener
00506         {       
00507         public:
00508                 CIteratorContener(const CIteratorContener &i):CConstIteratorContener(i._I)
00509                 {
00510                 }
00511 
00512                 CIteratorContener(const CConstIteratorContener &i):CConstIteratorContener(i)
00513                 {
00514                 }
00515 
00516                 CIteratorContener(IBasicIterator *i):CConstIteratorContener(i)
00517                 {
00518                 }
00519 
00520                 virtual ~CIteratorContener()
00521                 {               
00522                 }
00523 
00524                 virtual void erase()
00525                 {
00526                         _I->erase();
00527                 }
00528 
00529         };
00530         
00539         class IBaseGroupType: public IObjetOp
00540         {
00541 
00542         public:
00543                 struct CMethodCall
00544                 {
00545                         CMethodCall(const char *name, int i): MethodName (name)
00546                         {                               
00547                                 Index = i;
00548                         }
00549                         CStringVarName MethodName;
00550                         sint32 Index;
00551                 };
00552                 static CMethodCall _Method[];   
00553 
00554         public:         
00555 
00556                 IBaseGroupType(const IBaseGroupType &c):IObjetOp(c){}           
00557                 IBaseGroupType();
00558                 virtual ~IBaseGroupType();
00559                 
00561 
00562                 virtual IObjetOp &operator += (IObjetOp *a);
00563                 virtual IObjetOp &operator -= (IObjetOp *a);
00564                 virtual IObjetOp &operator += (const IObjetOp &a);
00565                 virtual IObjetOp &operator -= (const IObjetOp &a);
00566 
00567                 virtual IObjetOp *operator ! () const = 0;
00568                 virtual bool isTrue() const;
00570 
00572 
00573                 virtual sint32 getMethodIndexSize() const;
00574                 virtual sint32 isClassInheritedFrom(const IVarName &) const;
00575                 virtual tQueue isMember(const IVarName *,const IVarName *,const IObjectIA &) const;
00576                 virtual CProcessResult runMethodeMember(sint32, sint32, IObjectIA *);
00577                 virtual CProcessResult runMethodeMember(sint32 index,IObjectIA *);
00579                 
00581 
00582                 virtual IObjectIA &operator = (const IObjectIA &a) = 0;
00583                 virtual const IObjectIA *operator[] (sint32) const= 0;
00584                 
00586                 virtual void set(int,IObjectIA *) = 0;          
00587                 
00589                 virtual void push(const IObjectIA *o) = 0;
00591                 virtual void pushFront(const IObjectIA *o) = 0;
00593                 virtual void cpy(const IObjectIA &o) = 0;
00595                 virtual CIteratorContener getIterator() = 0;
00596                 virtual CConstIteratorContener getConstIterator() const = 0;
00597 
00599                 virtual const IObjectIA *pop() = 0;
00601                 virtual const IObjectIA *popFront() = 0;
00603                 virtual const IObjectIA *get() const = 0;               
00605                 virtual const IObjectIA *getFront() const = 0;
00607                 virtual sint32 size() const = 0;
00608 
00610                 virtual const IObjectIA *find(const IObjectIA &obj) const = 0;
00611                 
00612                 //virtual void eraseFirst(const IObjectIA &) = 0;
00614                 virtual void eraseAll(const IObjectIA &) = 0; 
00616                 virtual void erase(const IObjectIA *) = 0; 
00618                 virtual void erase(const IObjectIA &) = 0;
00620                 virtual void erase(std::list<const IObjectIA *> &) = 0;
00622                 virtual void clear() = 0;
00624         };
00633         class CGroupType: public IBaseGroupType
00634         {
00635 
00636         public:
00637                 static const NLAIC::CIdentType IdGroupType;
00638                 
00639         public:
00640                 //typedef of the std::list constainer
00641                 typedef std::list<const IObjectIA *> tListType;
00642         public:                         
00644                 tListType _List;
00645 
00646         protected:
00647 
00648                 tListType &getList();
00649 
00650         public:
00651                 CGroupType();
00652                 CGroupType(const CGroupType &g);
00653 
00654                 virtual void getDebugString(std::string &text) const;
00655 
00656                 virtual const CProcessResult &run();
00657 
00658                 virtual IObjectIA &operator = (const IObjectIA &a);
00659                 virtual IObjetOp *operator + (const IObjetOp &a);
00660                 virtual IObjetOp *operator - (const IObjetOp &a);
00661 
00662                 virtual IObjetOp *operator + (IObjetOp *a);
00663                 virtual IObjetOp *operator - (IObjetOp *a);             
00664 
00665                 virtual const IObjectIA *operator[] (sint32) const;
00666 
00667                 virtual void set(int,IObjectIA *);
00668 
00669                 virtual CIteratorContener getIterator()
00670                 {
00671                         return CIteratorContener(new CListIterator(_List));
00672                 }
00673 
00674                 virtual CConstIteratorContener getConstIterator() const
00675                 {
00676                         return CConstIteratorContener((IBasicIterator *)(new CConstListIterator(_List)));
00677                 }
00678 
00679 //              virtual bool isTrue() const;
00680 
00681                 IObjetOp *CGroupType::operator ! () const;
00682                 void push(const IObjectIA *o);
00683                 void pushFront(const IObjectIA *o);
00684                 void cpy(const IObjectIA &o);
00685                 const IObjectIA *pop();
00686                 const IObjectIA *get() const;
00687                 const IObjectIA *popFront();
00688                 const IObjectIA *getFront() const;
00689                 sint32 size() const;
00690                 tListType findList(const IObjectIA &obj) const;
00691                 tListType::const_iterator getBegin() const;
00692                 tListType::const_iterator getEnd() const;
00693                 tListType::iterator getBegin();
00694                 tListType::iterator getEnd();
00695                 const IObjectIA *find(const IObjectIA &obj) const;              
00696                 void eraseAll(const IObjectIA &obj); 
00697                 void erase(const IObjectIA *o); 
00698                 void erase(const IObjectIA &obj);
00699                 void erase(std::list<const IObjectIA *> &l);
00700                 virtual bool isEqual(const IBasicObjectIA &a) const;
00701                 virtual const NLAIC::IBasicType *clone() const;
00702                 virtual const NLAIC::IBasicType *newInstance() const;
00703                 virtual const NLAIC::CIdentType &getType() const;               
00704                 virtual void save(NLMISC::IStream &os);
00705                 virtual IObjetOp &neg();
00706                 virtual void load(NLMISC::IStream &is);
00707                 void clear();
00708 
00709                 virtual ~CGroupType();
00710         };
00711 
00720         class CVectorGroupType: public IBaseGroupType
00721         {
00722 
00723         public:
00724                 static const NLAIC::CIdentType IdVectorGroupType;
00725                 
00726         public:
00727                 //typedef of the std::vector constainer
00728                 typedef std::vector<const IObjectIA *> tVectorType;
00729         private:                                
00731                 tVectorType _Vector;            
00732 
00733         protected:
00734                 tVectorType &getVector();
00735 
00736         public:
00738                 CVectorGroupType(sint32 );
00739                 CVectorGroupType();
00740                 CVectorGroupType(const CVectorGroupType &g);
00741 
00742                 virtual void getDebugString(std::string &text) const;
00743 
00744                 virtual const CProcessResult &run();
00745                 
00746                 virtual IObjetOp *operator + (const IObjetOp &a) ;
00747                 virtual IObjetOp *operator - (const IObjetOp &a) ;
00748 
00749                 virtual IObjetOp *operator + (IObjetOp *a);
00750                 virtual IObjetOp *operator - (IObjetOp *a);             
00751 
00752                 virtual IObjectIA &operator = (const IObjectIA &a);
00753 
00754                 virtual const IObjectIA *operator[] (sint32) const;
00755 
00756                 virtual void set(int,IObjectIA *);
00757 
00758                 // virtual bool isTrue() const;
00759 
00760                 IObjetOp *CVectorGroupType::operator ! () const;
00761                 void push(const IObjectIA *o);
00762                 void pushFront(const IObjectIA *o);
00763                 virtual CIteratorContener getIterator()
00764                 {
00765                         return CIteratorContener(new CVectorIterator(_Vector));
00766                 }
00767 
00768                 virtual CConstIteratorContener getConstIterator() const
00769                 {
00770                         return CConstIteratorContener((IBasicIterator *)(new CConstVectorIterator(_Vector)));
00771                 }
00772 
00773                 void setObject(sint32 i,IObjectIA *a)
00774                 {
00775                         _Vector[i] = a;
00776                 }
00777 
00778                 void cpy(const IObjectIA &o);
00779                 const IObjectIA *pop();
00780                 const IObjectIA *get() const;
00781                 const IObjectIA *popFront();
00782                 const IObjectIA *getFront() const;
00783                 sint32 size() const;
00784                 tVectorType findList(const IObjectIA &obj) const;
00785                 tVectorType::const_iterator getBegin() const;
00786                 tVectorType::const_iterator getEnd() const;
00787                 tVectorType::iterator getBegin();
00788                 tVectorType::iterator getEnd();
00789                 const IObjectIA *find(const IObjectIA &obj) const;              
00790                 void eraseAll(const IObjectIA &obj); 
00791                 void erase(const IObjectIA *o); 
00792                 void erase(const IObjectIA &obj);
00793                 void erase(std::list<const IObjectIA *> &l);
00794                 virtual bool isEqual(const IBasicObjectIA &a) const;
00795                 virtual const NLAIC::IBasicType *clone() const;
00796                 virtual const NLAIC::IBasicType *newInstance() const;
00797                 virtual const NLAIC::CIdentType &getType() const;               
00798                 virtual void save(NLMISC::IStream &os);
00799                 virtual IObjetOp &neg();
00800                 virtual void load(NLMISC::IStream &is);
00801                 void clear();
00802 
00803                 virtual sint32 getMethodIndexSize() const;
00804                 virtual tQueue isMember(const IVarName *,const IVarName *,const IObjectIA &) const;
00805                 virtual CProcessResult runMethodeMember(sint32, sint32, IObjectIA *);
00806                 virtual CProcessResult runMethodeMember(sint32 index,IObjectIA *);
00807 
00808                 virtual ~CVectorGroupType();
00809         };
00810 /*
00811         class CMapGroupType: public IBaseGroupType
00812         {
00813 
00814         public:
00815                 static const NLAIC::CIdentType IdVectorGroupType;
00816                 
00817         public:
00818                 typedef std::vector<const IObjectIA *> tVectorType;
00819         private:                                
00821                 std::map<IObjectIA *, IObjectIA *> _Map;
00822 
00823         protected:
00824                 tVectorType &getVector();
00825 
00826         public:
00828                 CMapGroupType(sint32 );
00829                 CMapGroupType();
00830                 CMapGroupType(const CMapGroupType &g);
00831 
00832                 virtual void getDebugString(std::string &text) const;
00833 
00834                 virtual const CProcessResult &run();
00835 
00836                 virtual IObjetOp &operator += (const IObjetOp &a);
00837                 virtual IObjetOp &operator -= (const IObjetOp &a);
00838                 virtual IObjectIA &operator = (const IObjectIA &a);
00839 
00840                 virtual const IObjectIA *operator[] (sint32) const;
00841 
00842                 virtual void set(int,IObjectIA *);
00843 
00844                 // virtual bool isTrue() const;
00845 
00846                 IObjetOp *CMapGroupType::operator ! () const;
00847                 void push(const IObjectIA *o);
00848                 void pushFront(const IObjectIA *o);
00849                 virtual CIteratorContener getIterator()
00850                 {
00851                         return CIteratorContener(new CMapIterator(_Map));
00852                 }
00853 
00854 
00855                 virtual CConstIteratorContener getConstIterator() const
00856                 {
00857                         return CConstIteratorContener((IBasicIterator *)(new CConstMapIterator(_Map)));
00858                 }
00859 
00860                 void setObject(sint32 i,IObjectIA *a)
00861                 {
00862                         _Map[i] = a;
00863                 }
00864 
00865                 void cpy(const IObjectIA &o);
00866                 const IObjectIA *pop();
00867                 const IObjectIA *get() const;
00868                 const IObjectIA *popFront();
00869                 const IObjectIA *getFront() const;
00870                 sint32 size() const;
00871                 tVectorType findList(const IObjectIA &obj) const;
00872                 tVectorType::const_iterator getBegin() const;
00873                 tVectorType::const_iterator getEnd() const;
00874                 tVectorType::iterator getBegin();
00875                 tVectorType::iterator getEnd();
00876                 const IObjectIA *find(const IObjectIA &obj) const;              
00877                 void eraseAll(const IObjectIA &obj); 
00878                 void erase(const IObjectIA *o); 
00879                 void erase(const IObjectIA &obj);
00880                 void erase(std::list<const IObjectIA *> &l);
00881                 virtual bool isEqual(const IBasicObjectIA &a) const;
00882                 virtual const NLAIC::IBasicType *clone() const;
00883                 virtual const NLAIC::IBasicType *newInstance() const;
00884                 virtual const NLAIC::CIdentType &getType() const;               
00885                 virtual void save(NLMISC::IStream &os);
00886                 virtual IObjetOp &neg();
00887                 virtual void load(NLMISC::IStream &is);
00888                 void clear();
00889 
00890                 virtual sint32 getMethodIndexSize() const;
00891                 virtual tQueue isMember(const IVarName *,const IVarName *,const IObjectIA &) const;
00892                 virtual CProcessResult runMethodeMember(sint32, sint32, IObjectIA *);
00893                 virtual CProcessResult runMethodeMember(sint32 index,IObjectIA *);
00894 
00895                 virtual ~CMapGroupType();
00896         };
00897 */
00898 }
00899 #endif
agent_object.h
