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_OPERATOR_H
+00026 #define NL_AGENT_OPERATOR_H
+00027 
+00028 //#include "nel/ai/c/abstract_interface.h"
+00029 #include "nel/ai/agent/baseai.h"
+00030 
+00031 
+00032 namespace NLAIAGENT
+00033 {       
+00043         class IObjetOp: public IObjectIA
+00044         {
+00045         public:         
+00046                 enum TOpId 
+00047                 {
+00048                         op_add ,
+00049                         op_sub ,
+00050                         op_mul ,
+00051                         op_div ,
+00052                         op_eq ,
+00053                         op_inf ,
+00054                         op_sup ,
+00055                         op_inf_eq ,
+00056                         op_sup_eq ,
+00057                         op_not ,
+00058                         op_diff ,                       
+00059                         op_neg,
+00060                         op_last
+00061                 };      
+00062         public:         
+00063 
+00065 
+00066                 virtual tQueue IObjetOp::isMember(const IVarName *,const IVarName *,const IObjectIA &) const; 
+00067                 virtual CProcessResult IObjetOp::runMethodeMember(sint32 index, IObjectIA *);
+00068                 virtual sint32 getMethodIndexSize() const;
+00070 
+00071                 IObjetOp()
+00072                 {                       
+00073                 }               
+00074 
+00075                 IObjetOp(const IObjetOp &a):IObjectIA(a)
+00076                 {                       
+00077                 }               
+00078 
+00081 
+00082 
+00083                 virtual IObjetOp &operator += (const IObjetOp &)
+00084                 {                       
+00085                         std::string text;
+00086                         text = NLAIC::stringGetBuild("opertor <IObjectIA &operator += (const IObjectIA &a)> note implemented for the '%s' interface",(const char *)getType());
+00087                         throw NLAIE::CExceptionNotImplemented(text.c_str());
+00088                         return *this;
+00089                 }
+00090 
+00092                 virtual IObjetOp &operator -= (const IObjetOp &)
+00093                 {
+00094                         std::string text;
+00095                         text = NLAIC::stringGetBuild("opertor <IObjectIA &operator -= (const IObjectIA &a)> note implemented for the '%s' interface",(const char *)getType());
+00096                         throw NLAIE::CExceptionNotImplemented(text.c_str());
+00097                         return *this;
+00098                 }
+00099 
+00101                 virtual IObjetOp &neg()
+00102                 {
+00103                         std::string text;
+00104                         text = NLAIC::stringGetBuild("opertor <IObjectIA &neg()> note implemented for the '%s' interface",(const char *)getType());
+00105                         throw NLAIE::CExceptionNotImplemented(text.c_str());
+00106                         return *this;
+00107                 }               
+00108 
+00110                 virtual IObjetOp &operator *= (const IObjetOp &)
+00111                 {
+00112                         std::string text;
+00113                         text = NLAIC::stringGetBuild("opertor <IObjectIA &operator *= (const IObjectIA &a)> note implemented for the '%s' interface",(const char *)getType());
+00114                         throw NLAIE::CExceptionNotImplemented(text.c_str());
+00115                         return *this;
+00116                 }
+00117 
+00119                 virtual IObjetOp &operator /= (const IObjetOp &)
+00120                 {
+00121                         std::string text;
+00122                         text = NLAIC::stringGetBuild("opertor <IObjectIA &operator /= (const IObjectIA &a)> note implemented for the '%s' interface",(const char *)getType());
+00123                         throw NLAIE::CExceptionNotImplemented(text.c_str());
+00124                         return *this;
+00125                 }       
+00126 
+00127 
+00129 
+00130 
+00131                 virtual IObjetOp *operator + (const IObjetOp &) 
+00132                 {
+00133                         std::string text;
+00134                         text = NLAIC::stringGetBuild("opertor <virtual IObjetOp *operator + (const IObjetOp &a)  const> note implemented for the '%s' interface",(const char *)getType());
+00135                         throw NLAIE::CExceptionNotImplemented(text.c_str());
+00136                         return (IObjetOp *)this;
+00137                 }
+00138 
+00139                 virtual IObjetOp *operator - (const IObjetOp &) 
+00140                 {
+00141                         std::string text;
+00142                         text = NLAIC::stringGetBuild("opertor <virtual IObjetOp *operator - (const IObjetOp &a)  const> note implemented for the '%s' interface",(const char *)getType());
+00143                         throw NLAIE::CExceptionNotImplemented(text.c_str());
+00144                         return (IObjetOp *)this;
+00145                 }
+00146 
+00147                 virtual IObjetOp *operator * (const IObjetOp &) 
+00148                 {
+00149                         std::string text;
+00150                         text = NLAIC::stringGetBuild("opertor <virtual IObjetOp *operator * (const IObjetOp &a)  const> note implemented for the '%s' interface",(const char *)getType());
+00151                         throw NLAIE::CExceptionNotImplemented(text.c_str());
+00152                         return (IObjetOp *)this;
+00153                 }
+00154 
+00155                 virtual IObjetOp *operator / (const IObjetOp &)  
+00156                 {
+00157                         std::string text;
+00158                         text = NLAIC::stringGetBuild("opertor <virtual IObjetOp *operator / (const IObjetOp &a)  const> note implemented for the '%s' interface",(const char *)getType());
+00159                         throw NLAIE::CExceptionNotImplemented(text.c_str());
+00160                         return (IObjetOp *)this;
+00161                 }
+00163 
+00164 
+00165                 virtual IObjetOp *getNeg() const
+00166                 {
+00167                         IObjetOp *o = (IObjetOp *)clone();                      
+00168                         o->neg();
+00169                         return o;
+00170                 }
+00171 
+00172                 
+00173                 virtual IObjetOp &operator += (IObjetOp *a) 
+00174                 {
+00175                         return *this += *a;
+00176                 }
+00177                 virtual IObjetOp &operator -= (IObjetOp *a) 
+00178                 {
+00179                         return *this -= *a;
+00180 
+00181                 }
+00182                 virtual IObjetOp &operator *= (IObjetOp *a) 
+00183                 {
+00184                         return *this *= *a;
+00185 
+00186                 }
+00187                 virtual IObjetOp &operator /= (IObjetOp *a) 
+00188                 {
+00189                         return *this /= *a;
+00190 
+00191                 }
+00192                 
+00193                 virtual IObjetOp *operator + (IObjetOp *a) 
+00194                 {
+00195                         return *this + *a;
+00196                 }
+00197                 virtual IObjetOp *operator - (IObjetOp *a) 
+00198                 {
+00199                         return *this - *a;
+00200 
+00201                 }
+00202                 virtual IObjetOp *operator * (IObjetOp *a) 
+00203                 {
+00204                         return *this * *a;
+00205 
+00206                 }
+00207                 virtual IObjetOp *operator / (IObjetOp *a) 
+00208                 {
+00209                         return *this / *a;
+00210 
+00211                 }
+00212 
+00213                 virtual IObjetOp *operator < (IObjetOp &)  const 
+00214                 {
+00215                         std::string text;
+00216                         text = NLAIC::stringGetBuild("opertor <virtual IObjetOp *operator < (const IObjetOp &a)  const> note implemented for the '%s' interface",(const char *)getType());
+00217                         throw NLAIE::CExceptionNotImplemented(text.c_str());
+00218                         return (IObjetOp *)this;
+00219                 }
+00220 
+00221                 virtual IObjetOp *operator > (IObjetOp &)  const 
+00222                 {
+00223                         std::string text;
+00224                         text = NLAIC::stringGetBuild("opertor <virtual IObjetOp *operator > (const IObjetOp &a)  const> note implemented for the '%s' interface",(const char *)getType());
+00225                         throw NLAIE::CExceptionNotImplemented(text.c_str());
+00226                         return (IObjetOp *)this;
+00227                 }
+00228 
+00229                 virtual IObjetOp *operator <= (IObjetOp &)  const 
+00230                 {
+00231                         std::string text;
+00232                         text = NLAIC::stringGetBuild("opertor <virtual IObjetOp *operator <= (const IObjetOp &a)  const> note implemented for the '%s' interface",(const char *)getType());
+00233                         throw NLAIE::CExceptionNotImplemented(text.c_str());
+00234                         return (IObjetOp *)this;
+00235                 }
+00236 
+00237                 virtual IObjetOp *operator >= (IObjetOp &)  const 
+00238                 {
+00239                         std::string text;
+00240                         text = NLAIC::stringGetBuild("opertor <virtual IObjetOp *operator >= (const IObjetOp &a)  const> note implemented for the '%s' interface",(const char *)getType());
+00241                         throw NLAIE::CExceptionNotImplemented(text.c_str());
+00242                         return (IObjetOp *)this;
+00243                 }
+00244                 
+00245                 virtual IObjetOp *operator ! ()  const 
+00246                 {
+00247                         std::string text;
+00248                         text = NLAIC::stringGetBuild("opertor <virtual IObjetOp *operator ! ()  const> note implemented for the '%s' interface",(const char *)getType());
+00249                         throw NLAIE::CExceptionNotImplemented(text.c_str());
+00250                         return (IObjetOp *)this;
+00251                 }
+00252                 virtual IObjetOp *operator != (IObjetOp &) const 
+00253                 {
+00254                         std::string text;
+00255                         text = NLAIC::stringGetBuild("opertor <virtual IObjetOp *operator != (const IObjetOp &a)  const> note implemented for the '%s' interface",(const char *)getType());
+00256                         throw NLAIE::CExceptionNotImplemented(text.c_str());
+00257                         return (IObjetOp *)this;
+00258                 }               
+00259 
+00260                 virtual IObjetOp *operator == (IObjetOp &) const 
+00261                 {
+00262                         std::string text;
+00263                         text = NLAIC::stringGetBuild("opertor <virtual IObjetOp *operator == (const IObjetOp &a)  const> note implemented for the '%s' interface",(const char *)getType());
+00264                         throw NLAIE::CExceptionNotImplemented(text.c_str());
+00265                         return (IObjetOp *)this;
+00266                 }
+00267 
+00268                 virtual bool isTrue() const = 0;
+00269 
+00270                 virtual ~IObjetOp()
+00271                 {                       
+00272                 }
+00273         };
+00274 
+00275         inline bool IObjetOp::isTrue() const 
+00276         {                       
+00277                 std::string text;
+00278                 text = NLAIC::stringGetBuild("'bool isTrue() const' note implemented for the '%s' interface",(const char *)getType());
+00279                 throw NLAIE::CExceptionNotImplemented(text.c_str());
+00280                 return false;           
+00281         }
+00282 }
+00283 
+00284 #endif
+
agent_operator.h
