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 IVarName &str): _Str((IVarName *)str.clone())
00052                 {                       
00053                 }
00054 
00055                 CStringType(const CStringType &a): _Str((IVarName *)a._Str->clone())
00056                 {                       
00057                 }               
00058 
00059                 CStringType(NLMISC::IStream &is)
00060                 {
00061                         load(is);
00062                 }
00063                 
00064                 virtual const NLAIC::IBasicType *clone() const
00065                 {
00066                         NLAIC::IBasicInterface *m = new CStringType(*this);
00067                         return m;
00068                 }               
00069 
00070                 virtual const NLAIC::IBasicType *newInstance() const
00071                 {
00072                         return clone();
00073                 }
00074                 
00075                 virtual const NLAIC::CIdentType &getType() const;               
00076 
00077                 virtual void save(NLMISC::IStream &os)
00078                 {                       
00079                         os.serial( (NLAIC::CIdentType &) ( _Str->getType() ) );
00080                         _Str->save(os);
00081                 }
00082 
00083                 virtual void load(NLMISC::IStream &is)
00084                 {                       
00085                         NLAIC::CIdentTypeAlloc id;
00086                         is.serial( id );
00087                         _Str->release();
00088                         _Str = (IVarName *)id.allocClass();                     
00089                         _Str->load(is);                 
00090                 }
00091 
00092                 virtual void getDebugString(char *text) const
00093                 {
00094                         sprintf(text,"%s",_Str->getString());
00095                 }
00096 
00097                 const IVarName & getStr() const
00098                 {
00099                         return *_Str;
00100                 }
00101 
00103 
00104                 virtual IObjetOp &operator += (const IObjetOp &a);              
00105                 virtual IObjetOp &operator -= (const IObjetOp &a);              
00106                 virtual IObjetOp *operator < (IObjetOp &a) const;
00107                 virtual IObjetOp *operator > (IObjetOp &a) const;
00108                 virtual IObjetOp *operator <= (IObjetOp &a) const;      
00109                 virtual IObjetOp *operator >= (IObjetOp &a) const;      
00110                 virtual IObjetOp *operator != (IObjetOp &a) const;
00112 
00113 
00114                 virtual bool operator < (const CStringType &a) const;
00115 
00116 
00117                 virtual bool isTrue() const
00118                 {
00119                         return IObjetOp::isTrue();
00120                 }
00121                 
00122                 virtual ~CStringType()
00123                 {       
00124                         _Str->release();
00125                 }       
00126                 
00127                 virtual bool isEqual(const IBasicObjectIA &a) const
00128                 {
00129                         const CStringType &t = (const CStringType &)a;
00130                         return *t._Str == *_Str;
00131                 }
00132                         
00133 
00134                 virtual const CProcessResult &run();            
00135         };
00136 
00137                 
00138 
00139         /*
00140         class CPaireType: public IObjetOp
00141         {
00142         private:                
00143                 CStringType     _ValueName;
00144                 IObjectIA *_Value;              
00145 
00146         public:
00147                 static const NLAIC::CIdentType IdPaireType;
00148                 
00149         public:
00150                 CPaireType(const CStringType &valueName,const IObjectIA &value): 
00151                   _ValueName(valueName),_Value((IObjectIA *)value.clone())
00152                 {                       
00153                 }
00154 
00155                 CPaireType(const CPaireType &a): _ValueName(a._ValueName),_Value((IObjectIA *)a._Value->clone())
00156                 {
00157                 }                               
00158 
00159                 virtual const NLAIC::IBasicType *clone() const
00160                 {
00161                         NLAIC::IBasicInterface *m = new CPaireType(*this);
00162                         return m;
00163                 }
00164 
00165                 virtual const NLAIC::IBasicType *newInstance() const
00166                 {
00167                         return clone();
00168                 }
00169                 
00170                 virtual const NLAIC::CIdentType &getType() const;
00171                 
00172 
00173                 virtual void save(NLMISC::IStream &os)
00174                 {                                               
00175                         _ValueName.save(os);
00176                         os.serial( (NLAIC::CIdentType &) (_Value->getType()) );
00177                         _Value->save(os);                       
00178                 }
00179 
00180                 virtual void load(NLMISC::IStream &is)
00181                 {                                               
00182                         _ValueName.load(is);
00183                         _Value->release();
00184                         NLAIC::CIdentTypeAlloc id;
00185                         is.serial(id);
00186                         _Value = (IObjectIA *)id.allocClass();
00187                         _Value->load(is);                       
00188                 }
00189 
00190                 virtual const CProcessResult &run();
00191 
00192                 virtual void getDebugString(char *text) const;          
00193 
00194                 virtual bool isTrue() const
00195                 {
00196                         return IObjetOp::isTrue();
00197                 }
00198                 
00199 
00200                 operator const IObjectIA *() const
00201                 {
00202                         return _Value;
00203                 }
00204 
00205                 operator const CStringType& ()
00206                 {
00207                         return _ValueName;
00208 
00209                 }
00210                 virtual ~CPaireType()
00211                 {                       
00212                         _Value->release();
00213                 }       
00214 
00215                 virtual bool isEqual(const IBasicObjectIA &a) const
00216                 {
00217                         const CPaireType &t = (const CPaireType &)a;
00218                         if(((IObjectIA &)t._ValueName) == ((IObjectIA &)_ValueName)) return t._Value == _Value;
00219                         return false;
00220                 }
00221         };
00222         */
00223 
00234         class IBasicIterator
00235         {
00236         public:
00237                 virtual const IObjetOp* operator ++ (int) = 0;
00238                 virtual const IObjetOp* operator -- (int) = 0;
00239                 virtual operator const IObjetOp*() const = 0;           
00240                 virtual bool isInEnd() const = 0;
00241                 virtual bool isInBegin() const = 0;
00242         };
00243 
00251         template<class typeClass>
00252         class CTemplateIterator: public IBasicIterator
00253         {
00254         private:
00255                 typename typeClass::const_iterator _I;
00256                 const typeClass &_ListType;
00257                 
00258         public:
00259                 CTemplateIterator(const typeClass &l):_I(l.begin()),_ListType(l)
00260                 {
00261                 }
00262                 ~CTemplateIterator()
00263                 {
00264                 }
00265 
00266                 virtual const IObjetOp* operator ++ (int) 
00267                 {
00268                         return (const IObjetOp*)*_I++;
00269                 }
00270                 virtual const IObjetOp* operator -- (int)
00271                 {
00272                         return (const IObjetOp*)*_I--;
00273                 }
00274 
00275                 virtual operator const IObjetOp *() const
00276                 {
00277                         return (const IObjetOp *)*_I;
00278                 }               
00279 
00280                 virtual bool isInEnd() const
00281                 {
00282                         
00283                         return _I == _ListType.end();
00284                 
00285                 }
00286                 virtual bool isInBegin() const
00287                 {
00288                         return _I == _ListType.begin();
00289                 }
00290         };
00291 
00300         class CListIterator: public CTemplateIterator<std::list<const IObjectIA *> >
00301         {
00302         public:
00303                 CListIterator(const std::list<const IObjectIA *> &l):
00304                   CTemplateIterator<std::list<const IObjectIA *> >(l)
00305                   {
00306                   }
00307 
00308         };
00309         
00317         class CVectorIterator: public CTemplateIterator<std::vector<const IObjectIA *> >
00318         {
00319         public:
00320                 CVectorIterator(const std::vector<const IObjectIA *>&l):
00321                   CTemplateIterator<std::vector<const IObjectIA *> >(l)
00322                   {
00323                   }
00324 
00325         };
00326 
00335         class CIteratorContener: public IBasicIterator
00336         {
00337         private:
00338                 IBasicIterator *_I;
00339         public:
00340                 CIteratorContener(IBasicIterator *i):_I(i)
00341                 {
00342                 }
00343                 ~CIteratorContener()
00344                 {
00345                         delete _I;
00346                 }
00347 
00348                 virtual const IObjetOp*operator ++ (int) 
00349                 {
00350                         const IObjetOp *a = (*_I)++;                       
00351                         return a;
00352                 }
00353                 virtual const IObjetOp*operator -- (int)
00354                 {
00355                         const IObjetOp *a = (*_I) --;                      
00356                         return a;
00357                 }
00358 
00359                 virtual operator const IObjetOp*() const
00360                 {
00361                         return (const IObjetOp *)*_I;
00362                 }               
00363                 
00364                 virtual bool isInEnd() const 
00365                 {                       
00366                         return _I->isInEnd();
00367                 }
00368                 virtual bool isInBegin() const
00369                 {
00370                         return _I->isInBegin();
00371                 }
00372         };
00373         
00382         class IBaseGroupType: public IObjetOp
00383         {
00384 
00385         public:
00386                 struct CMethodCall
00387                 {
00388                         CMethodCall(const char *name, int i): MethodName (name)
00389                         {                               
00390                                 Index = i;
00391                         }
00392                         CStringVarName MethodName;
00393                         sint32 Index;
00394                 };
00395                 static CMethodCall _Method[];   
00396 
00397         public:         
00398 
00399                 IBaseGroupType(const IBaseGroupType &c):IObjetOp(c){}           
00400                 IBaseGroupType();
00401                 virtual ~IBaseGroupType();
00402                 
00404 
00405                 virtual IObjetOp &operator += (const IObjetOp &a) = 0;
00406                 virtual IObjetOp &operator -= (const IObjetOp &a) = 0;
00407                 virtual IObjetOp *operator + (const IObjetOp &a)  const
00408                 {
00409                         IObjetOp *o = (IObjetOp *)clone();                      
00410                         *o += a;
00411                         return o;
00412                 }
00413                 virtual IObjetOp *operator - (const IObjetOp &a)  const
00414                 {
00415                         IObjetOp *o = (IObjetOp *)clone();
00416                         *o -= a;
00417                         return o;
00418                 }
00419                 virtual IObjetOp *operator ! () const = 0;
00420                 virtual bool isTrue() const;
00422 
00424 
00425                 virtual sint32 getMethodIndexSize() const;
00426                 virtual sint32 isClassInheritedFrom(const IVarName &) const;
00427                 virtual tQueue isMember(const IVarName *,const IVarName *,const IObjectIA &) const;
00428                 virtual CProcessResult runMethodeMember(sint32, sint32, IObjectIA *);
00429                 virtual CProcessResult runMethodeMember(sint32 index,IObjectIA *);
00431                 
00433 
00434                 virtual IObjectIA &operator = (const IObjectIA &a) = 0;
00435                 virtual const IObjectIA *operator[] (sint32) const= 0;
00436                 
00438                 virtual void set(int,IObjectIA *) = 0;          
00439                 
00441                 virtual void push(const IObjectIA *o) = 0;
00443                 virtual void pushFront(const IObjectIA *o) = 0;
00445                 virtual void cpy(const IObjectIA &o) = 0;
00447                 virtual CIteratorContener getIterator() const = 0;
00448 
00450                 virtual const IObjectIA *pop() = 0;
00452                 virtual const IObjectIA *popFront() = 0;
00454                 virtual const IObjectIA *get() const = 0;               
00456                 virtual const IObjectIA *getFront() const = 0;
00458                 virtual sint32 size() const = 0;
00459 
00461                 virtual const IObjectIA *find(const IObjectIA &obj) const = 0;
00462                 
00463                 //virtual void eraseFirst(const IObjectIA &) = 0;
00465                 virtual void eraseAll(const IObjectIA &) = 0; 
00467                 virtual void erase(const IObjectIA *) = 0; 
00469                 virtual void erase(const IObjectIA &) = 0;
00471                 virtual void erase(std::list<const IObjectIA *> &) = 0;
00473                 virtual void clear() = 0;
00475         };
00484         class CGroupType: public IBaseGroupType
00485         {
00486 
00487         public:
00488                 static const NLAIC::CIdentType IdGroupType;
00489                 
00490         public:
00491                 //typedef of the std::list constainer
00492                 typedef std::list<const IObjectIA *> tListType;
00493         public:                         
00495                 tListType _List;
00496 
00497         protected:
00498 
00499                 tListType &getList();
00500 
00501         public:
00502                 CGroupType();
00503                 CGroupType(const CGroupType &g);
00504 
00505                 virtual void getDebugString(char *text) const;
00506 
00507                 virtual const CProcessResult &run();
00508 
00509                 virtual IObjetOp &operator += (const IObjetOp &a);
00510                 virtual IObjetOp &operator -= (const IObjetOp &a);
00511                 virtual IObjectIA &operator = (const IObjectIA &a);
00512 
00513                 virtual const IObjectIA *operator[] (sint32) const;
00514 
00515                 virtual void set(int,IObjectIA *);
00516 
00517                 virtual CIteratorContener getIterator() const
00518                 {
00519                         return CIteratorContener(new CListIterator(_List));
00520                 }
00521 
00522 //              virtual bool isTrue() const;
00523 
00524                 IObjetOp *CGroupType::operator ! () const;
00525                 void push(const IObjectIA *o);
00526                 void pushFront(const IObjectIA *o);
00527                 void cpy(const IObjectIA &o);
00528                 const IObjectIA *pop();
00529                 const IObjectIA *get() const;
00530                 const IObjectIA *popFront();
00531                 const IObjectIA *getFront() const;
00532                 sint32 size() const;
00533                 tListType findList(const IObjectIA &obj) const;
00534                 tListType::const_iterator getBegin() const;
00535                 tListType::const_iterator getEnd() const;
00536                 tListType::iterator getBegin();
00537                 tListType::iterator getEnd();
00538                 const IObjectIA *find(const IObjectIA &obj) const;              
00539                 void eraseAll(const IObjectIA &obj); 
00540                 void erase(const IObjectIA *o); 
00541                 void erase(const IObjectIA &obj);
00542                 void erase(std::list<const IObjectIA *> &l);
00543                 virtual bool isEqual(const IBasicObjectIA &a) const;
00544                 virtual const NLAIC::IBasicType *clone() const;
00545                 virtual const NLAIC::IBasicType *newInstance() const;
00546                 virtual const NLAIC::CIdentType &getType() const;               
00547                 virtual void save(NLMISC::IStream &os);
00548                 virtual IObjetOp &neg();
00549                 virtual void load(NLMISC::IStream &is);
00550                 void clear();
00551 
00552                 virtual ~CGroupType();
00553         };
00554 
00563         class CVectorGroupType: public IBaseGroupType
00564         {
00565 
00566         public:
00567                 static const NLAIC::CIdentType IdVectorGroupType;
00568                 
00569         public:
00570                 //typedef of the std::vector constainer
00571                 typedef std::vector<const IObjectIA *> tVectorType;
00572         private:                                
00574                 tVectorType _Vector;            
00575 
00576         protected:
00577                 tVectorType &getVector();
00578 
00579         public:
00580                 CVectorGroupType(sint32 );
00581                 CVectorGroupType();
00582                 CVectorGroupType(const CVectorGroupType &g);
00583 
00584                 virtual void getDebugString(char *text) const;
00585 
00586                 virtual const CProcessResult &run();
00587 
00588                 virtual IObjetOp &operator += (const IObjetOp &a);
00589                 virtual IObjetOp &operator -= (const IObjetOp &a);
00590                 virtual IObjectIA &operator = (const IObjectIA &a);
00591 
00592                 virtual const IObjectIA *operator[] (sint32) const;
00593 
00594                 virtual void set(int,IObjectIA *);
00595 
00596                 // virtual bool isTrue() const;
00597 
00598                 IObjetOp *CVectorGroupType::operator ! () const;
00599                 void push(const IObjectIA *o);
00600                 void pushFront(const IObjectIA *o);
00601                 virtual CIteratorContener getIterator() const
00602                 {
00603                         return CIteratorContener(new CVectorIterator(_Vector));
00604                 }
00605 
00606                 void setObject(sint32 i,IObjectIA *a)
00607                 {
00608                         _Vector[i] = a;
00609                 }
00610 
00611                 void cpy(const IObjectIA &o);
00612                 const IObjectIA *pop();
00613                 const IObjectIA *get() const;
00614                 const IObjectIA *popFront();
00615                 const IObjectIA *getFront() const;
00616                 sint32 size() const;
00617                 tVectorType findList(const IObjectIA &obj) const;
00618                 tVectorType::const_iterator getBegin() const;
00619                 tVectorType::const_iterator getEnd() const;
00620                 tVectorType::iterator getBegin();
00621                 tVectorType::iterator getEnd();
00622                 const IObjectIA *find(const IObjectIA &obj) const;              
00623                 void eraseAll(const IObjectIA &obj); 
00624                 void erase(const IObjectIA *o); 
00625                 void erase(const IObjectIA &obj);
00626                 void erase(std::list<const IObjectIA *> &l);
00627                 virtual bool isEqual(const IBasicObjectIA &a) const;
00628                 virtual const NLAIC::IBasicType *clone() const;
00629                 virtual const NLAIC::IBasicType *newInstance() const;
00630                 virtual const NLAIC::CIdentType &getType() const;               
00631                 virtual void save(NLMISC::IStream &os);
00632                 virtual IObjetOp &neg();
00633                 virtual void load(NLMISC::IStream &is);
00634                 void clear();
00635 
00636                 virtual sint32 getMethodIndexSize() const;
00637                 virtual tQueue isMember(const IVarName *,const IVarName *,const IObjectIA &) const;
00638                 virtual CProcessResult runMethodeMember(sint32, sint32, IObjectIA *);
00639                 virtual CProcessResult runMethodeMember(sint32 index,IObjectIA *);
00640 
00641                 virtual ~CVectorGroupType();
00642         };
00643 }
00644 #endif
agent_object.h
