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 {       
00035         
00045         class DigitalType : public IDigital<float>
00046         {
00047 
00048         public:
00049                 static DigitalType NullOperator;
00050 
00051                 static const NLAIC::CIdentType IdDigitalType;
00052 
00053         public:
00055                 DigitalType(float value):IDigital<float>(value)
00056                 {                       
00057                 }
00058 
00060                 DigitalType():IDigital<float>()
00061                 {                       
00062                 }
00063                 
00064                 DigitalType(const DigitalType &a):IDigital<float>(a)
00065                 {                       
00066                 }
00067 
00069                 DigitalType(NLMISC::IStream &is):IDigital<float>(is)
00070                 {
00071                 }
00072 
00073                 virtual IObjetOp &neg()
00074                 {
00075                         _Value = -_Value;
00076                         chekBorn();
00077                         return *this;
00078                 }
00079                 
00081 
00082                 virtual const NLAIC::IBasicType *clone() const
00083                 {
00084                         NLAIC::IBasicInterface *m = new DigitalType(*this);                     
00085                         return m;
00086                 }
00087                 
00088                 virtual const NLAIC::IBasicType *newInstance() const
00089                 {
00090                         return clone();
00091                 }
00092 
00093                 virtual const NLAIC::CIdentType &getType() const;               
00094                         
00095                 virtual void getDebugString(std::string &text) const
00096                 {                       
00097                         text += NLAIC::stringGetBuild("%f",getValue());
00098                 }               
00099 
00100                 virtual const CProcessResult &run();
00102         };
00103 
00104 
00113         class BorneDigitalType: public IBornNombre<float>
00114         {                       
00115 
00116         public:
00117                 static const NLAIC::CIdentType IdBorneDigitalType;
00118 
00119         public:
00120 
00124                 BorneDigitalType(float sup,float inf,float value): IBornNombre<float>(value,sup,inf)
00125                 {
00126                 }
00130                 BorneDigitalType(float sup,float inf):IBornNombre<float>(sup,inf)
00131                 {
00132                 }               
00133 
00134                 BorneDigitalType(const BorneDigitalType &a): IBornNombre<float>(a)
00135                 {
00136                 }                               
00137 
00139                 BorneDigitalType(NLMISC::IStream &is):IBornNombre<float>(is)
00140                 {
00141                 }
00142 
00143                 virtual IObjetOp &neg()
00144                 {
00145                         _Value = -_Value;
00146                         chekBorn();
00147                         return *this;
00148                 }
00149 
00151 
00152                 virtual const NLAIC::IBasicType *clone() const
00153                 {
00154                         NLAIC::IBasicInterface *m = new BorneDigitalType(*this);                        
00155                         return m;
00156                 }               
00157 
00158                 virtual const NLAIC::IBasicType *newInstance() const
00159                 {
00160                         return clone();
00161                 }
00162 
00163                 virtual const NLAIC::CIdentType &getType() const;                               
00164 
00165                 virtual const CProcessResult &run();
00166                 
00167                 virtual void getDebugString(std::string &text) const
00168                 {
00169                         text += NLAIC::stringGetBuild("%f [_inf<%f> _sup<%f>]",getValue(),getInf(),getSup());
00170                 }
00172 
00173         protected:              
00174         };
00175 
00186         class DDigitalType : public IDigital<double>
00187         {
00188 
00189         public:
00190                 static const NLAIC::CIdentType IdDDigitalType;
00191 
00192         public:
00194                 DDigitalType(double value):IDigital<double>(value)
00195                 {                       
00196                 }
00197 
00199                 DDigitalType():IDigital<double>()
00200                 {                       
00201                 }
00202                 
00203                 DDigitalType(const DDigitalType &a):IDigital<double>(a)
00204                 {                       
00205                 }
00206 
00208                 DDigitalType(NLMISC::IStream &is):IDigital<double>(is)
00209                 {
00210                 }
00211 
00212                 virtual IObjetOp &neg()
00213                 {
00214                         _Value = -_Value;
00215                         chekBorn();
00216                         return *this;
00217                 }
00218                 
00220 
00221                 virtual const NLAIC::IBasicType *clone() const
00222                 {
00223                         NLAIC::IBasicInterface *m = new DDigitalType(*this);                    
00224                         return m;
00225                 }
00226                 
00227                 virtual const NLAIC::IBasicType *newInstance() const
00228                 {
00229                         return clone();
00230                 }
00231 
00232                 virtual const NLAIC::CIdentType &getType() const;               
00233                 
00234 
00235                 virtual void getDebugString(std::string &text) const
00236                 {
00237                         text += NLAIC::stringGetBuild("%.5f",getValue());
00238                 }               
00239 
00240                 virtual const CProcessResult &run();
00242         };
00243 
00253         class BorneDDigitalType: public IBornNombre<double>
00254         {
00255 
00256         public:
00257                 static const NLAIC::CIdentType IdBorneDDigitalType;
00258 
00259         public:
00260 
00264                 BorneDDigitalType(double sup,double inf,double value): IBornNombre<double>(value,sup,inf)
00265                 {
00266                 }
00270                 BorneDDigitalType(double sup,double inf):IBornNombre<double>(sup,inf)
00271                 {
00272                 }               
00273 
00274                 BorneDDigitalType(const BorneDDigitalType &a): IBornNombre<double>(a)
00275                 {
00276                 }               
00277 
00279                 BorneDDigitalType(NLMISC::IStream &is):IBornNombre<double>(is)
00280                 {
00281                 }
00282 
00283 
00284                 virtual IObjetOp &neg()
00285                 {
00286                         _Value = -_Value;
00287                         chekBorn();
00288                         return *this;
00289                 }
00290 
00292 
00293                 virtual const NLAIC::IBasicType *clone() const
00294                 {
00295                         NLAIC::IBasicInterface *m = new BorneDDigitalType(*this);                       
00296                         return m;
00297                 }               
00298 
00299                 virtual const NLAIC::IBasicType *newInstance() const
00300                 {
00301                         return clone();
00302                 }
00303 
00304                 virtual const NLAIC::CIdentType &getType() const;                               
00305 
00306                 virtual const CProcessResult &run();
00307                 
00308                 virtual void getDebugString(std::string &text) const
00309                 {
00310                         text += NLAIC::stringGetBuild("%e [_inf<%e> _sup<%e>]",getValue(),getInf(),getSup());
00311                 }
00313 
00314         protected:              
00315         };
00316 
00317 
00327         class IntegerType: public IDigital<sint32>
00328         {
00329         public:
00330 
00331                 static const NLAIC::CIdentType IdIntegerType;
00332 
00333         public:
00334                 IntegerType(sint32 value):IDigital<sint32>(value)
00335                 {                       
00336                 }
00337 
00338                 IntegerType():IDigital<sint32>()
00339                 {                       
00340                 }
00341 
00342                 IntegerType(const IntegerType &a):IDigital<sint32>(a)
00343                 {                       
00344                 }
00345 
00346                 IntegerType(NLMISC::IStream &is):IDigital<sint32>(is)
00347                 {
00348                 }
00349 
00350                 virtual IObjetOp &neg()
00351                 {
00352                         _Value = -_Value;
00353                         chekBorn();
00354                         return *this;
00355                 }
00356                 
00357 
00358                 virtual const NLAIC::IBasicType *clone() const
00359                 {
00360                         NLAIC::IBasicInterface *m = new IntegerType(*this);                     
00361                         return m;
00362                 }
00363                 
00364                 virtual const NLAIC::IBasicType *newInstance() const
00365                 {
00366                         return clone();
00367                 }
00368 
00369                 virtual const NLAIC::CIdentType &getType() const;               
00370                 
00371 
00372                 virtual void getDebugString(std::string &text) const
00373                 {
00374 
00375                         text += NLAIC::stringGetBuild("%d",getValue());
00376                 }               
00377 
00378                 virtual const CProcessResult &run();
00379         };
00380 
00390         class ShortIntegerType: public IDigital<sint16>
00391         {
00392         public:
00393 
00394                 static const NLAIC::CIdentType IdShortIntegerType;
00395 
00396         public:
00397                 ShortIntegerType(sint16 value):IDigital<sint16>(value)
00398                 {                       
00399                 }
00400 
00401                 ShortIntegerType():IDigital<sint16>()
00402                 {                       
00403                 }
00404 
00405                 ShortIntegerType(const ShortIntegerType &a):IDigital<sint16>(a)
00406                 {                       
00407                 }
00408 
00409                 ShortIntegerType(NLMISC::IStream &is):IDigital<sint16>(is)
00410                 {
00411                 }
00412 
00413                 virtual IObjetOp &neg()
00414                 {
00415                         _Value = -_Value;
00416                         chekBorn();
00417                         return *this;
00418                 }
00419                 
00420 
00421                 virtual const NLAIC::IBasicType *clone() const
00422                 {
00423                         NLAIC::IBasicInterface *m = new ShortIntegerType(*this);                        
00424                         return m;
00425                 }
00426                 
00427                 virtual const NLAIC::IBasicType *newInstance() const
00428                 {
00429                         return clone();
00430                 }
00431 
00432                 virtual const NLAIC::CIdentType &getType() const;               
00433                 
00434 
00435                 virtual void getDebugString(std::string &text) const
00436                 {
00437                         text += NLAIC::stringGetBuild("%d",getValue());
00438                 }               
00439 
00440                 virtual const CProcessResult &run();
00441         };
00442 
00452         class CharType: public IDigital<sint8>
00453         {
00454         public:
00455 
00456                 static const NLAIC::CIdentType IdCharType;
00457 
00458         public:
00459                 CharType(sint8 value):IDigital<sint8>(value)
00460                 {                       
00461                 }
00462 
00463                 CharType():IDigital<sint8>()
00464                 {                       
00465                 }
00466 
00467                 CharType(const CharType &a):IDigital<sint8>(a)
00468                 {                       
00469                 }
00470 
00471                 CharType(NLMISC::IStream &is):IDigital<sint8>(is)
00472                 {
00473                 }
00474 
00475                 virtual IObjetOp &neg()
00476                 {
00477                         _Value = -_Value;
00478                         chekBorn();
00479                         return *this;
00480                 }
00481                 
00482                 virtual const NLAIC::IBasicType *clone() const
00483                 {
00484                         NLAIC::IBasicInterface *m = new CharType(*this);                        
00485                         return m;
00486                 }
00487                 
00488                 virtual const NLAIC::IBasicType *newInstance() const
00489                 {
00490                         return clone();
00491                 }
00492 
00493                 virtual const NLAIC::CIdentType &getType() const;               
00494                 
00495 
00496                 virtual void getDebugString(std::string &text) const
00497                 {
00498                         text += NLAIC::stringGetBuild("%d",getValue());
00499                 }               
00500 
00501                 virtual const CProcessResult &run();
00502         };
00503 
00504         
00514         class UInt8Type: public IDigital<uint8>
00515         {
00516         public:
00517 
00518                 static const NLAIC::CIdentType IdUInt8Type;
00519 
00520         public:
00521                 UInt8Type(sint8 value):IDigital<uint8>(value)
00522                 {                       
00523                 }
00524 
00525                 UInt8Type():IDigital<uint8>()
00526                 {                       
00527                 }
00528 
00529                 UInt8Type(const UInt8Type &a):IDigital<uint8>(a)
00530                 {                       
00531                 }
00532 
00533                 UInt8Type(NLMISC::IStream &is):IDigital<uint8>(is)
00534                 {
00535                 }
00536 
00537                 
00538                 virtual const NLAIC::IBasicType *clone() const
00539                 {
00540                         NLAIC::IBasicInterface *m = new UInt8Type(*this);                       
00541                         return m;
00542                 }
00543                 
00544                 virtual const NLAIC::IBasicType *newInstance() const
00545                 {
00546                         return clone();
00547                 }
00548 
00549                 virtual const NLAIC::CIdentType &getType() const;               
00550                 
00551 
00552                 virtual void getDebugString(std::string &text) const
00553                 {
00554                         text += NLAIC::stringGetBuild("%d",getValue());
00555                 }               
00556 
00557                 virtual const CProcessResult &run();
00558 
00559                 virtual IObjetOp &neg()
00560                 {
00561                         chekBorn();
00562                         return *this;
00563                 }
00564         };
00565 
00575         class UInt16Type: public IDigital<uint16>
00576         {
00577         public:
00578 
00579                 static const NLAIC::CIdentType IdUInt16Type;
00580 
00581         public:
00582                 UInt16Type(uint16 value):IDigital<uint16>(value)
00583                 {                       
00584                 }
00585 
00586                 UInt16Type():IDigital<uint16>()
00587                 {                       
00588                 }
00589 
00590                 UInt16Type(const UInt16Type &a):IDigital<uint16>(a)
00591                 {                       
00592                 }
00593 
00594                 UInt16Type(NLMISC::IStream &is):IDigital<uint16>(is)
00595                 {
00596                 }
00597                 
00598                 virtual const NLAIC::IBasicType *clone() const
00599                 {
00600                         NLAIC::IBasicInterface *m = new UInt16Type(*this);                      
00601                         return m;
00602                 }
00603                 
00604                 virtual const NLAIC::IBasicType *newInstance() const
00605                 {
00606                         return clone();
00607                 }
00608 
00609                 virtual const NLAIC::CIdentType &getType() const;               
00610                 
00611 
00612                 virtual void getDebugString(std::string &text) const
00613                 {
00614                         text += NLAIC::stringGetBuild("%d",getValue());
00615                 }               
00616 
00617                 virtual const CProcessResult &run();
00618 
00619                 virtual IObjetOp &neg()
00620                 {
00621                         chekBorn();
00622                         return *this;
00623                 }
00624 
00625         };
00626 
00634         class UInt32Type: public IDigital<uint32>
00635         {
00636         public:
00637 
00638                 static const NLAIC::CIdentType IdUInt32Type;
00639 
00640         public:
00641                 UInt32Type(uint32 value):IDigital<uint32>(value)
00642                 {                       
00643                 }
00644 
00645                 UInt32Type():IDigital<uint32>()
00646                 {                       
00647                 }
00648 
00649                 UInt32Type(const UInt32Type &a):IDigital<uint32>(a)
00650                 {                       
00651                 }
00652 
00653                 UInt32Type(NLMISC::IStream &is):IDigital<uint32>(is)
00654                 {
00655                 }
00656                 
00657                 virtual const NLAIC::IBasicType *clone() const
00658                 {
00659                         NLAIC::IBasicInterface *m = new UInt32Type(*this);                      
00660                         return m;
00661                 }
00662                 
00663                 virtual const NLAIC::IBasicType *newInstance() const
00664                 {
00665                         return clone();
00666                 }
00667 
00668                 virtual const NLAIC::CIdentType &getType() const;               
00669                 
00670 
00671                 virtual void getDebugString(std::string &text) const
00672                 {
00673                         text += NLAIC::stringGetBuild("%d",getValue());
00674                 }               
00675 
00676                 virtual const CProcessResult &run();
00677 
00678                 virtual IObjetOp &neg()
00679                 {
00680                         chekBorn();
00681                         return *this;
00682                 }
00683 
00684         };
00685 
00693         class UInt64Type: public INombre<uint64>
00694         {
00695         public:
00696 
00697                 static const NLAIC::CIdentType IdUInt64Type;
00698 
00699         public:
00700                 UInt64Type(uint64 value):INombre<uint64>(value)
00701                 {                       
00702                 }
00703 
00704                 UInt64Type():INombre<uint64>()
00705                 {                       
00706                 }
00707 
00708                 UInt64Type(const UInt64Type &a):INombre<uint64>(a)
00709                 {                       
00710                 }
00711 
00712                 UInt64Type(NLMISC::IStream &is):INombre<uint64>(is)
00713                 {
00714                 }
00715                 
00716                 virtual const NLAIC::IBasicType *clone() const
00717                 {
00718                         NLAIC::IBasicInterface *m = new UInt64Type(*this);
00719                         return m;
00720                 }
00721                 
00722                 virtual const NLAIC::IBasicType *newInstance() const
00723                 {
00724                         return clone();
00725                 }
00726 
00727                 virtual const NLAIC::CIdentType &getType() const;               
00728                 
00729 
00730                 virtual void getDebugString(std::string &text) const
00731                 {
00732                         text += NLAIC::stringGetBuild("%d",getValue());
00733                 }               
00734 
00735                 virtual const CProcessResult &run();
00736 
00737                 virtual double getNumber() const;               
00738 
00739                 virtual IObjetOp &neg()
00740                 {
00741                         chekBorn();
00742                         return *this;
00743                 }
00744 
00745         };
00746 
00747 }
00748 #endif
agent_digital.h
