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_NOMBRE_H
+00026 #define NL_AGENT_NOMBRE_H
+00027 
+00028 //#include "nel/ai/agent/agent_object.h" 
+00029 #include "nel/ai/logic/boolval.h"
+00030 #include "nel/misc/vector.h"
+00031 
+00032 namespace NLAIAGENT
+00033 {       
+00034 
+00041         class INombreDefine: public IObjetOp
+00042         {
+00043 
+00044         public:
+00045 
+00047                 enum  TMethodNumDef {
+00048                         TConst, 
+00049                         TLastM 
+00050                 };
+00051 
+00053                 struct CMethodCall
+00054                 {
+00055                         CMethodCall(const char *name, int i): MethodName (name)
+00056                         {                               
+00057                                 Index = i;
+00058                         }
+00060                         CStringVarName MethodName;
+00062                         sint32 Index;
+00063                 };
+00065                 static CMethodCall StaticMethod[];
+00066 
+00067         public:
+00068                 INombreDefine()
+00069                 {
+00070                 }
+00071 
+00072                 INombreDefine(const INombreDefine &value):IObjetOp(value)
+00073                 {
+00074                 }
+00075 
+00077 
+00078                 virtual sint32 getMethodIndexSize() const;
+00079                 virtual sint32 isClassInheritedFrom(const IVarName &) const;
+00080                 virtual tQueue isMember(const IVarName *,const IVarName *,const IObjectIA &) const;             
+00082 
+00083 
+00086                 virtual double getNumber() const = 0;
+00087                 virtual ~INombreDefine()
+00088                 {
+00089                 }
+00090 
+00091         };
+00092 
+00101         template <class tNombre> 
+00102         class INombre: public INombreDefine
+00103         {       
+00104 
+00105         protected:
+00106                 tNombre _Value;
+00107 
+00108         public:
+00109                 INombre(tNombre value):_Value(value)
+00110                 {
+00111                 }
+00112                 INombre(const INombre &value):INombreDefine(value),_Value((tNombre)value._Value)
+00113                 {
+00114                 }
+00115                 INombre()
+00116                 {                       
+00117                 }
+00118                 INombre(NLMISC::IStream &is)
+00119                 {
+00120                         load(is);
+00121                 }
+00122 
+00123                 virtual ~INombre()
+00124                 {
+00125                 }               
+00126 
+00128 
+00129                 virtual CProcessResult runMethodeMember(sint32, sint32, IObjectIA *)
+00130                 {
+00131                         return IObjectIA::CProcessResult();
+00132                 }
+00133                 virtual CProcessResult runMethodeMember(sint32 index,IObjectIA *p)
+00134                 {
+00135                         IBaseGroupType *param = (IBaseGroupType *)p;
+00136 
+00137                         switch(index - IObjetOp::getMethodIndexSize())
+00138                         {
+00139                         case INombreDefine::TConst:
+00140                                 {                                       
+00141                                         _Value = (tNombre )((INombreDefine *)param->get())->getNumber();
+00142                                         return IObjectIA::CProcessResult();             
+00143                                 }
+00144                         }
+00145 
+00146                         return IObjectIA::CProcessResult();
+00147                 }
+00149 
+00150                 virtual void save(NLMISC::IStream &os)
+00151                 {       
+00152                         tNombre v = _Value;
+00153                         // TODO
+00154                         os.serial( v );
+00155                 }
+00156 
+00157                 virtual void load(NLMISC::IStream &is)
+00158                 {                               
+00159                         // TODO
+00160                         is.serial( _Value );                    
+00161 
+00162                 }               
+00163 
+00164                 virtual bool isEqual(const IBasicObjectIA &a) const
+00165                 {                       
+00166                         return !(*(IObjectIA *)this == (IObjetOp &)a);
+00167                 }
+00168 
+00169                 virtual bool isTrue() const
+00170                 {
+00171                         return _Value != (tNombre)0;
+00172                 }
+00173 
+00174                 tNombre getValue() const
+00175                 {
+00176                         return _Value;
+00177                 }
+00178 
+00179                 void setValue(tNombre value) 
+00180                 {
+00181                         _Value = value;
+00182                 }               
+00183 
+00184                 virtual IObjectIA &operator = (const IObjectIA &a)
+00185                 {                       
+00186                         tNombre v = (tNombre)((const INombreDefine &)a).getNumber();
+00187                         _Value = v;
+00188                         chekBorn();
+00189                         return *this;
+00190                 }
+00191 
+00192                 virtual IObjetOp &operator += (const IObjetOp &a)
+00193                 {
+00194                         tNombre v = (tNombre)((const INombreDefine &)a).getNumber();
+00195                         addValue(v);
+00196                         return *this;
+00197                 }
+00198 
+00199                 virtual IObjetOp &operator -= (const IObjetOp &a)
+00200                 {
+00201                         tNombre v = (tNombre)((const INombreDefine &)a).getNumber();
+00202                         subValue(v);
+00203                         return *this;
+00204                 }
+00205 
+00206                 virtual IObjetOp &neg() = 0;            
+00207 
+00208                 virtual IObjetOp &operator *= (const IObjetOp &a)
+00209                 {
+00210                         tNombre v = (tNombre)((const INombreDefine &)a).getNumber();
+00211                         mulValue(v);
+00212                         return *this;
+00213                 }
+00214 
+00215                 virtual IObjetOp &operator /= (const IObjetOp &a)
+00216                 {
+00217                         tNombre v = (tNombre)((const INombreDefine &)a).getNumber();
+00218                         divValue(v);
+00219                         return *this;
+00220                 }
+00221 
+00222                 virtual IObjetOp *operator + (const IObjetOp &a)
+00223                 {
+00224                         IObjetOp *o = (IObjetOp *)clone();                      
+00225                         *o += a;
+00226                         return o;
+00227                 }
+00228 
+00229                 virtual IObjetOp *operator - (const IObjetOp &a)
+00230                 {
+00231                         IObjetOp *o = (IObjetOp *)clone();                      
+00232                         *o -= a;
+00233                         return o;
+00234                 }
+00235 
+00236                 virtual IObjetOp *operator * (const IObjetOp &a)
+00237                 {
+00238                         IObjetOp *o = (IObjetOp *)clone();                      
+00239                         *o *= a;
+00240                         return o;
+00241                 }
+00242 
+00243                 virtual IObjetOp *operator / (const IObjetOp &a)
+00244                 {
+00245                         IObjetOp *o = (IObjetOp *)clone();                      
+00246                         *o /= a;
+00247                         return o;
+00248                 }
+00249 
+00250 
+00251                 virtual IObjetOp *operator < (IObjetOp &a) const
+00252                 {
+00253                         tNombre v = (tNombre)((const INombreDefine &)a).getNumber();
+00254                         NLAILOGIC::CBoolType *x = new NLAILOGIC::CBoolType(_Value < v);                 
+00255                         return x;
+00256                 }
+00257 
+00258                 virtual IObjetOp *operator > (IObjetOp &a) const
+00259                 {
+00260                         tNombre v = (tNombre)((const INombreDefine &)a).getNumber();
+00261                         NLAILOGIC::CBoolType *x = new NLAILOGIC::CBoolType(_Value > v);                 
+00262                         return x;
+00263                 }
+00264 
+00265                 virtual IObjetOp *operator <= (IObjetOp &a) const
+00266                 {
+00267                         tNombre v = (tNombre)((const INombre &)a).getNumber();
+00268                         NLAILOGIC::CBoolType *x = new NLAILOGIC::CBoolType(_Value <= v);                        
+00269                         return x;
+00270                 }
+00271 
+00272                 virtual IObjetOp *operator >= (IObjetOp &a) const
+00273                 {
+00274                         tNombre v = (tNombre)((const INombre &)a).getNumber();
+00275                         NLAILOGIC::CBoolType *x = new NLAILOGIC::CBoolType(_Value >= v);                        
+00276                         return x;
+00277                 }
+00278 
+00279                 virtual IObjetOp *operator ! () const
+00280                 {                       
+00281                         NLAILOGIC::CBoolType *x = new NLAILOGIC::CBoolType(_Value == (tNombre)0);                       
+00282                         return x;
+00283                 }
+00284 
+00285                 virtual IObjetOp *operator != (IObjetOp &a) const
+00286                 {
+00287                         tNombre v = (tNombre)((const INombreDefine &)a).getNumber();
+00288                         NLAILOGIC::CBoolType *x = new NLAILOGIC::CBoolType(_Value != v);
+00289                         return x;
+00290                 }
+00291 
+00292                 virtual IObjetOp *operator == (IObjetOp &a) const
+00293                 {
+00294                         tNombre v = (tNombre)((const INombreDefine &)a).getNumber();
+00295                         NLAILOGIC::CBoolType *x = new NLAILOGIC::CBoolType(_Value == v);
+00296                         return x;
+00297                 }
+00298 
+00299                 
+00300         protected:
+00301 
+00302                 virtual void chekBorn(){}
+00303                 
+00304                 void addValue(tNombre value)
+00305                 {
+00306                         _Value += value;
+00307                         chekBorn();
+00308                 }
+00309 
+00310                 void subValue(tNombre value)
+00311                 {
+00312                         _Value -= value;
+00313                         chekBorn();
+00314                 }
+00315 
+00316                 void mulValue(tNombre value)
+00317                 {
+00318                         _Value *= value;
+00319                         chekBorn();
+00320                 }
+00321 
+00322                 void divValue(tNombre value)
+00323                 {
+00324                         _Value /= value;
+00325                         chekBorn();
+00326                 }
+00327         };
+00328 
+00329         template <class tNombre> 
+00330         class IDigital : public INombre<tNombre>
+00331         {
+00332 
+00333         public :
+00334                 IDigital(tNombre value):INombre<tNombre>(value)
+00335                 {
+00336                 }
+00337 
+00338                 IDigital(const IDigital &value):INombre<tNombre>(value)
+00339                 {
+00340                 }
+00341                 
+00342                 IDigital()
+00343                 {                       
+00344                 }
+00345                 
+00346                 IDigital(NLMISC::IStream &is):INombre<tNombre>(is)
+00347                 {
+00348                 }
+00349                 
+00350                 virtual ~IDigital()
+00351                 {
+00352                 }
+00353 
+00354                 virtual double getNumber() const
+00355                 {
+00356                         return (double)_Value;
+00357                 }
+00358         };
+00359 
+00360         template <class tNombre> 
+00361         class  IBornNombre: public IDigital<tNombre>
+00362         {
+00363         private:
+00364                 tNombre _inf,_sup;
+00365         public:
+00366                 IBornNombre(tNombre value,tNombre inf,tNombre sup):IDigital<tNombre>(value),_inf((tNombre)inf),_sup((tNombre)sup)
+00367                 {
+00368                 }
+00369                 IBornNombre(const IBornNombre &value):IDigital<tNombre>(value),_inf((tNombre)value._inf),_sup((tNombre)value._sup)
+00370                 {
+00371                 }
+00372                 IBornNombre(tNombre inf,tNombre sup):_inf((tNombre)inf),_sup((tNombre)sup)
+00373                 {                       
+00374                 }
+00375                 IBornNombre(NLMISC::IStream &is):IDigital<tNombre>(is)
+00376                 {                       
+00377                 }
+00378                 virtual ~IBornNombre()
+00379                 {
+00380                 }
+00381 
+00382                 virtual void save(NLMISC::IStream &)
+00383                 {
+00384 /*                      IDigital<tNombre>::save(os);
+00385                         os.serial( _sup );
+00386                         os.serial(_inf );*/
+00387                 }
+00388 
+00389                 virtual void load(NLMISC::IStream &)
+00390                 {
+00391                         // TODO
+00392 /*                      IDigital<tNombre>::load(is);
+00393                         is.serial( _sup );
+00394                         is.serial( _inf );*/
+00395                 }
+00396 
+00397                 tNombre getSup() const
+00398                 {
+00399                         return _sup;
+00400                 }
+00401                 tNombre getInf() const
+00402                 {
+00403                         return _inf;
+00404                 }
+00405         protected:
+00406 
+00407                 void chekBorn()
+00408                 {
+00409                         if(_Value > _sup) _Value = _sup;
+00410                         if(_Value < _inf) _Value = _inf;
+00411                 }                                       
+00412         };
+00413 }
+00414 
+00415 #endif
+
agent_nombre.h
