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 
00026 #ifndef NL_AGENT_DIGITAL_H
00027 #define NL_AGENT_DIGITAL_H
00028 
00029 #include "nel/ai/agent/agent.h"
00030 #include "nel/ai/agent/agent_object.h"
00031 #include "nel/ai/agent/agent_nombre.h"
00032 
00033 namespace NLAIAGENT
00034 {       
00044         class DigitalType : public INombre<float>
00045         {
00046 
00047         public:
00048                 static DigitalType NullOperator;
00049 
00050                 static const NLAIC::CIdentType IdDigitalType;
00051 
00052         public:
00054                 DigitalType(float value):INombre<float>(value)
00055                 {                       
00056                 }
00057 
00059                 DigitalType():INombre<float>()
00060                 {                       
00061                 }
00062                 
00063                 DigitalType(const DigitalType &a):INombre<float>(a)
00064                 {                       
00065                 }
00066 
00068                 DigitalType(NLMISC::IStream &is):INombre<float>(is)
00069                 {
00070                 }
00071                 
00073 
00074                 virtual const NLAIC::IBasicType *clone() const
00075                 {
00076                         NLAIC::IBasicInterface *m = new DigitalType(*this);                     
00077                         return m;
00078                 }
00079                 
00080                 virtual const NLAIC::IBasicType *newInstance() const
00081                 {
00082                         return clone();
00083                 }
00084 
00085                 virtual const NLAIC::CIdentType &getType() const;               
00086                 
00087 
00088                 virtual void getDebugString(char *text) const
00089                 {
00090                         sprintf(text,"<float> %f",getValue());
00091                 }               
00092 
00093                 virtual const CProcessResult &run();
00095         };
00096 
00105         class BorneDigitalType: public IBornNombre<float>
00106         {                       
00107 
00108         public:
00109                 static const NLAIC::CIdentType IdBorneDigitalType;
00110 
00111         public:
00112 
00116                 BorneDigitalType(float sup,float inf,float value): IBornNombre<float>(value,sup,inf)
00117                 {
00118                 }
00122                 BorneDigitalType(float sup,float inf):IBornNombre<float>(sup,inf)
00123                 {
00124                 }               
00125 
00126                 BorneDigitalType(const BorneDigitalType &a): IBornNombre<float>(a)
00127                 {
00128                 }                               
00129 
00131                 BorneDigitalType(NLMISC::IStream &is):IBornNombre<float>(is)
00132                 {
00133                 }
00134 
00136 
00137                 virtual const NLAIC::IBasicType *clone() const
00138                 {
00139                         NLAIC::IBasicInterface *m = new BorneDigitalType(*this);                        
00140                         return m;
00141                 }               
00142 
00143                 virtual const NLAIC::IBasicType *newInstance() const
00144                 {
00145                         return clone();
00146                 }
00147 
00148                 virtual const NLAIC::CIdentType &getType() const;                               
00149 
00150                 virtual const CProcessResult &run();
00151                 
00152                 virtual void getDebugString(char *text) const
00153                 {
00154                         sprintf(text,"_Value<%f> [_inf<%f> _sup<%f>]",getValue(),getInf(),getSup());
00155                 }
00157 
00158         protected:              
00159         };
00160 
00171         class DDigitalType : public INombre<double>
00172         {
00173 
00174         public:
00175                 static const NLAIC::CIdentType IdDDigitalType;
00176 
00177         public:
00179                 DDigitalType(double value):INombre<double>(value)
00180                 {                       
00181                 }
00182 
00184                 DDigitalType():INombre<double>()
00185                 {                       
00186                 }
00187                 
00188                 DDigitalType(const DDigitalType &a):INombre<double>(a)
00189                 {                       
00190                 }
00191 
00193                 DDigitalType(NLMISC::IStream &is):INombre<double>(is)
00194                 {
00195                 }
00196                 
00198 
00199                 virtual const NLAIC::IBasicType *clone() const
00200                 {
00201                         NLAIC::IBasicInterface *m = new DDigitalType(*this);                    
00202                         return m;
00203                 }
00204                 
00205                 virtual const NLAIC::IBasicType *newInstance() const
00206                 {
00207                         return clone();
00208                 }
00209 
00210                 virtual const NLAIC::CIdentType &getType() const;               
00211                 
00212 
00213                 virtual void getDebugString(char *text) const
00214                 {
00215                         sprintf(text,"%.5e",getValue());
00216                 }               
00217 
00218                 virtual const CProcessResult &run();
00220         };
00221 
00231         class BorneDDigitalType: public IBornNombre<double>
00232         {                       
00233 
00234         public:
00235                 static const NLAIC::CIdentType IdBorneDDigitalType;
00236 
00237         public:
00238 
00242                 BorneDDigitalType(double sup,double inf,double value): IBornNombre<double>(value,sup,inf)
00243                 {
00244                 }
00248                 BorneDDigitalType(double sup,double inf):IBornNombre<double>(sup,inf)
00249                 {
00250                 }               
00251 
00252                 BorneDDigitalType(const BorneDDigitalType &a): IBornNombre<double>(a)
00253                 {
00254                 }                               
00255 
00257                 BorneDDigitalType(NLMISC::IStream &is):IBornNombre<double>(is)
00258                 {
00259                 }
00260 
00262 
00263                 virtual const NLAIC::IBasicType *clone() const
00264                 {
00265                         NLAIC::IBasicInterface *m = new BorneDDigitalType(*this);                       
00266                         return m;
00267                 }               
00268 
00269                 virtual const NLAIC::IBasicType *newInstance() const
00270                 {
00271                         return clone();
00272                 }
00273 
00274                 virtual const NLAIC::CIdentType &getType() const;                               
00275 
00276                 virtual const CProcessResult &run();
00277                 
00278                 virtual void getDebugString(char *text) const
00279                 {
00280                         sprintf(text,"_Value<%e> [_inf<%e> _sup<%e>]",getValue(),getInf(),getSup());
00281                 }
00283 
00284         protected:              
00285         };
00286 
00287 
00297         class IntegerType: public INombre<sint32>
00298         {
00299         public:
00300 
00301                 static const NLAIC::CIdentType IdIntegerType;
00302 
00303         public:
00304                 IntegerType(sint32 value):INombre<sint32>(value)
00305                 {                       
00306                 }
00307 
00308                 IntegerType():INombre<sint32>()
00309                 {                       
00310                 }
00311 
00312                 IntegerType(const IntegerType &a):INombre<sint32>(a)
00313                 {                       
00314                 }
00315 
00316                 IntegerType(NLMISC::IStream &is):INombre<sint32>(is)
00317                 {
00318                 }
00319                 
00320 
00321                 virtual const NLAIC::IBasicType *clone() const
00322                 {
00323                         NLAIC::IBasicInterface *m = new IntegerType(*this);                     
00324                         return m;
00325                 }
00326                 
00327                 virtual const NLAIC::IBasicType *newInstance() const
00328                 {
00329                         return clone();
00330                 }
00331 
00332                 virtual const NLAIC::CIdentType &getType() const;               
00333                 
00334 
00335                 virtual void getDebugString(char *text) const
00336                 {
00337                         sprintf(text,"%d",getValue());
00338                 }               
00339 
00340                 virtual const CProcessResult &run();
00341         };
00342 
00352         class ShortIntegerType: public INombre<sint16>
00353         {
00354         public:
00355 
00356                 static const NLAIC::CIdentType IdShortIntegerType;
00357 
00358         public:
00359                 ShortIntegerType(sint16 value):INombre<sint16>(value)
00360                 {                       
00361                 }
00362 
00363                 ShortIntegerType():INombre<sint16>()
00364                 {                       
00365                 }
00366 
00367                 ShortIntegerType(const ShortIntegerType &a):INombre<sint16>(a)
00368                 {                       
00369                 }
00370 
00371                 ShortIntegerType(NLMISC::IStream &is):INombre<sint16>(is)
00372                 {
00373                 }
00374                 
00375 
00376                 virtual const NLAIC::IBasicType *clone() const
00377                 {
00378                         NLAIC::IBasicInterface *m = new ShortIntegerType(*this);                        
00379                         return m;
00380                 }
00381                 
00382                 virtual const NLAIC::IBasicType *newInstance() const
00383                 {
00384                         return clone();
00385                 }
00386 
00387                 virtual const NLAIC::CIdentType &getType() const;               
00388                 
00389 
00390                 virtual void getDebugString(char *text) const
00391                 {
00392                         sprintf(text,"%d",getValue());
00393                 }               
00394 
00395                 virtual const CProcessResult &run();
00396         };
00397 
00407         class CharType: public INombre<sint8>
00408         {
00409         public:
00410 
00411                 static const NLAIC::CIdentType IdCharType;
00412 
00413         public:
00414                 CharType(sint8 value):INombre<sint8>(value)
00415                 {                       
00416                 }
00417 
00418                 CharType():INombre<sint8>()
00419                 {                       
00420                 }
00421 
00422                 CharType(const CharType &a):INombre<sint8>(a)
00423                 {                       
00424                 }
00425 
00426                 CharType(NLMISC::IStream &is):INombre<sint8>(is)
00427                 {
00428                 }
00429                 
00430                 virtual const NLAIC::IBasicType *clone() const
00431                 {
00432                         NLAIC::IBasicInterface *m = new CharType(*this);                        
00433                         return m;
00434                 }
00435                 
00436                 virtual const NLAIC::IBasicType *newInstance() const
00437                 {
00438                         return clone();
00439                 }
00440 
00441                 virtual const NLAIC::CIdentType &getType() const;               
00442                 
00443 
00444                 virtual void getDebugString(char *text) const
00445                 {
00446                         sprintf(text,"%c",getValue());
00447                 }               
00448 
00449                 virtual const CProcessResult &run();
00450         };
00451 }
00452 
00453 
00454 #endif
agent_digital.h
