00001
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025 #ifndef NL_AGENT_NOMBRE_H
00026 #define NL_AGENT_NOMBRE_H
00027
00028
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
00154 os.serial( v );
00155 }
00156
00157 virtual void load(NLMISC::IStream &is)
00158 {
00159
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
00385
00386
00387 }
00388
00389 virtual void load(NLMISC::IStream &)
00390 {
00391
00392
00393
00394
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