NeL: NLAIAGENT::IVector class Reference

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                 };      
+

00055                                                      :_Value(x, y, z)
+00056                 {
+00057                 }
+

00059                                                 :_Value(v)
+00060                 {                       
+00061                 }
+

00063                                              :IObjetOp(value), _Value((NLMISC::CVectorD)value._Value)
+00064                 {
+00065                 }
+

00070                 {
+00071                         load(is);
+00072                 }
+

00351         {
+00352                 return TQueue();
+00353         }
+

00094                 {
+00095                         return --_Ref;
+00096                 }
+

00117                 {
+00118                         return std::string("<unnamed>");
+00119                 }
+

00293                 {
+00294                         std::string s;
+00295                         getDebugString(s);
+00296                         return s;
+00297                 }
+

00312         {
+00313                 switch(id)
+00314                 {
+00315                 case 0:
+00316                         {
+00317                                 return std::string("IObjectIA::sendMessage(IMessage)");
+00318                         }                       
+00319                         break;
+00320                 case 1:                 
+00321                         break;
+00322                 case 2:                 
+00323                         return std::string("IObjectIA::run()");
+00324                         break;
+00325 
+00326                 case 3:
+00327                         {                               
+00328                                 return std::string("IObjectIA::getStaticMember(Integer)");                              
+00329                         }
+00330                 }
+00331                 return std::string("Mathod_?????(Param_?????)");
+00332         }
+

00042         {
+00043                 return getMethodIndexSize() + 10;
+00044         }
+

00166                 {
+00167                         IObjetOp *o = (IObjetOp *)clone();                      
+00168                         o->neg();
+00169                         return o;
+00170                 }
+

00100                 {
+00101                         return _Ref;
+00102                 }
+

00262                 {
+00263                         return getStaticMember(getStaticMemberIndex(compName));
+00264                 }
+

00194         {
+00195                 return NULL;
+00196         }
+

00189         {
+00190                 return -1;
+00191         }
+

00181         {
+00182                 std::string text;
+00183                 text = NLAIC::stringGetBuild("sint32 IObjectIA::getStaticMemberSize() note implementaited for the '%s' interface",(const char *)getType());
+00184                 throw NLAIE::CExceptionNotImplemented(text.c_str());
+00185                 return 0;       
+00186         }
+

00104                 {
+00105                         return _Value;
+00106                 }
+

00099                 {
+00100                         return _Value;
+00101                 }
+

00081                 {
+00082                         _Ref ++;
+00083                 }
+

00117         {
+00118                 
+00119         }
+

00215         {
+00216 
+00218                 //Cette class n'a aucun heritage.
+00219                 const CStringVarName selfName((const char *)getType());
+00220                 //ça c'est si jamais quelqu'un ecrit un truc du type Vector.x() où Vector est le non de cette class dans le script.
+00221                 if((baseClass) == selfName) return 0;           
+00222                 else return -1;
+00224 /*
+00225                 //Cette class n'a aucun heritage.
+00226                 const CStringVarName selfName((const char *)getType());
+00227                 //ça c'est si jamais quelqu'un ecrit un truc du type Vector.x() où Vector est le non de cette class dans le script.
+00228                 if((baseClass) == selfName) return 0 + IObjetOp::getInheritedSize();
+00229                 else return IObjetOp::isClassInheritedFrom(baseClass);
+00230 */
+00231         }
+

00089                 {                       
+00090                         return !(*(IObjectIA *)this == (IObjetOp &)a);
+00091                 }
+

00357         {
+00358                 return true;
+00359         }
+

00050         {               
+00051                 //Type IVarName voir agent_string.h.
+00052                 static const CStringVarName methodX("x");
+00053                 static const CStringVarName methodY("y");
+00054                 static const CStringVarName methodZ("z");
+00055                 static const CStringVarName methodSquareLength("SquareLength");
+00056                 static const CStringVarName methodLength("Length");
+00057                 static const CStringVarName methodUnit("Unit");
+00058                 static const CStringVarName selfName((const char *)getType());
+00059                 static const CStringVarName constructor(_CONSTRUCTOR_);
+00060 
+00061                 //NLAISCRIPT::CParam est le type reel de p voir nel/ai/script/interpret_methodes.h pour la declaration de la class.
+00062                 const NLAISCRIPT::CParam &param = (const NLAISCRIPT::CParam &)p;
+00063                         
+00064                 if(baseClass == NULL || (*baseClass) == selfName)
+00065                 {
+00066                         if((*methodName) == methodX)
+00067                         {
+00068                                 if(!param.size())
+00069                                 {
+00070                                         TQueue a;
+00071                                         //Type du retour de la method x(), c'est un Float dont de type DDigitalType c'est à dire DDigitalType::IDDigitalType;
+00072                                         //CObjectType est un IObjectIA qui permet d'encapsuler un NLAIC::CIdentType c'est à dire un type.
+00073                                         NLAIAGENT::CObjectType *t = new NLAIAGENT::CObjectType(new NLAIC::CIdentType(DDigitalType::IdDDigitalType));
+00074                                         t->incRef();
+00075                                         //CIdMethod est dans basicai.h elle va être documenter.
+00076                                         a.push(CIdMethod(IObjetOp::getMethodIndexSize() + 1,0.0,NULL,t));
+00077                                         return a;
+00078                                 }
+00079                                 else
+00080                                 {
+00081                                         NLAISCRIPT::CParam xParam;
+00082                                         xParam.push(NLAISCRIPT::COperandSimple(new NLAIC::CIdentType(DDigitalType::IdDDigitalType)));
+00083                                         if(param == xParam)
+00084                                         {               
+00085                                                 TQueue a;
+00086                                                 //Type du retour de la method x(), c'est un void dont de type VoidType c'est à dire NLAIC::CIdentType::VoidType;
+00087                                                 //CObjectType est un IObjectIA qui permet d'encapsuler un NLAIC::CIdentType c'est à dire un type.
+00088                                                 //la variable NLAIC::CIdentType::VoidType est un static dans la class NLAIC::CIdentType.
+00089                                                 NLAIAGENT::CObjectType *t = new NLAIAGENT::CObjectType(new NLAIC::CIdentType(NLAIC::CIdentType::VoidType));
+00090                                                 t->incRef();
+00091                                                 //CIdMethod est dans basicai.h elle va être documenter.
+00092                                                 a.push(CIdMethod(IObjetOp::getMethodIndexSize() + 2,0.0,NULL,t));
+00093                                                 return a;
+00094                                         }
+00095                                 }
+00096                         }
+00097                         else if((*methodName) == methodY)
+00098                         {
+00099                                 if(!param.size())
+00100                                 {
+00101                                         TQueue a;
+00102                                         //Type du retour de la method y(), c'est un Float dont de type DDigitalType c'est à dire DDigitalType::IdDDigitalType;
+00103                                         //CObjectType est un IObjectIA qui permet d'encapsuler un NLAIC::CIdentType c'est à dire un type.
+00104                                         NLAIAGENT::CObjectType *t = new NLAIAGENT::CObjectType(new NLAIC::CIdentType(DDigitalType::IdDDigitalType));
+00105                                         t->incRef();
+00106                                         //CIdMethod est dans basicai.h elle va être documenter.
+00107                                         a.push(CIdMethod(IObjetOp::getMethodIndexSize() + 3,0.0,NULL,t));
+00108                                         return a;
+00109                                 }
+00110                                 else
+00111                                 {
+00112                                         NLAISCRIPT::CParam xParam;
+00113                                         xParam.push(NLAISCRIPT::COperandSimple(new NLAIC::CIdentType(DDigitalType::IdDDigitalType)));
+00114                                         if(param == xParam)
+00115                                         {               
+00116                                                 TQueue a;
+00117                                                 //Type du retour de la method y(), c'est un void dont de type VoidType c'est à dire CIdentType::VoidType;
+00118                                                 //CObjectType est un IObjectIA qui permet d'encapsuler un NLAIC::CIdentType c'est à dire un type.
+00119                                                 //la variable NLAIC::CIdentType::VoidType est un static dans la class NLAIC::CIdentType.
+00120                                                 NLAIAGENT::CObjectType *t = new NLAIAGENT::CObjectType(new NLAIC::CIdentType(NLAIC::CIdentType::VoidType));                                             
+00121                                                 //CIdMethod est dans basicai.h elle va être documenter.
+00122                                                 a.push(CIdMethod(IObjetOp::getMethodIndexSize() + 4,0.0,NULL,t));
+00123                                                 return a;
+00124                                         }
+00125                                 }
+00126                         }
+00127                         if((*methodName) == methodZ)
+00128                         {
+00129                                 if(!param.size())
+00130                                 {
+00131                                         TQueue a;
+00132                                         //Type du retour de la method x(), c'est un Float dont de type DDigitalType c'est à dire DDigitalType::IdDDigitalType;
+00133                                         //CObjectType est un IObjectIA qui permet d'encapsuler un NLAIC::CIdentType c'est à dire un type.
+00134                                         NLAIAGENT::CObjectType *t = new NLAIAGENT::CObjectType(new NLAIC::CIdentType(DDigitalType::IdDDigitalType));                                    
+00135                                         //CIdMethod est dans basicai.h elle va être documenter.
+00136                                         a.push(CIdMethod(IObjetOp::getMethodIndexSize() + 5,0.0,NULL,t));
+00137                                         return a;
+00138                                 }
+00139                                 else
+00140                                 {
+00141                                         NLAISCRIPT::CParam xParam;
+00142                                         xParam.push(NLAISCRIPT::COperandSimple(new NLAIC::CIdentType(DDigitalType::IdDDigitalType)));
+00143                                         if(param == xParam)
+00144                                         {               
+00145                                                 TQueue a;
+00146                                                 //Type du retour de la method x(), c'est un void dont de type VoidType c'est à dire NLAIC::CIdentType::VoidType;
+00147                                                 //CObjectType est un IObjectIA qui permet d'encapsuler un NLAIC::CIdentType c'est à dire un type.
+00148                                                 //la variable NLAIC::CIdentType::VoidType est un static dans la class NLAIC::CIdentType.
+00149                                                 NLAIAGENT::CObjectType *t = new NLAIAGENT::CObjectType(new NLAIC::CIdentType(NLAIC::CIdentType::VoidType));                                             
+00150                                                 //CIdMethod est dans basicai.h elle va être documenter.
+00151                                                 a.push(CIdMethod(IObjetOp::getMethodIndexSize() + 6,0.0,NULL,t));
+00152                                                 return a;
+00153                                         }
+00154                                 }
+00155                         }
+00156                         else if((*methodName) == methodSquareLength)
+00157                         {
+00158                                 if(!param.size())
+00159                                 {
+00160                                         TQueue a;
+00161                                         //Return a void type (no value return)
+00162                                         NLAIAGENT::CObjectType *t = new NLAIAGENT::CObjectType(new NLAIC::CIdentType(DDigitalType::IdDDigitalType));                                    
+00163                                         a.push(CIdMethod(IObjetOp::getMethodIndexSize() + 7,0.0,NULL,t));
+00164                                         return a;
+00165                                 }
+00166                         }
+00167                         else if((*methodName) == methodLength)
+00168                         {
+00169                                 if(!param.size())
+00170                                 {
+00171                                         TQueue a;
+00172                                         //Return a digital type
+00173                                         NLAIAGENT::CObjectType *t = new NLAIAGENT::CObjectType(new NLAIC::CIdentType(DDigitalType::IdDDigitalType));                                    
+00174                                         a.push(CIdMethod(IObjetOp::getMethodIndexSize() + 8,0.0,NULL,t));
+00175                                         return a;
+00176                                 }
+00177                         }
+00178                         else if((*methodName) == methodUnit)
+00179                         {
+00180                                 if(!param.size())
+00181                                 {
+00182                                         TQueue a;
+00183                                         //Return a void type
+00184                                         NLAIAGENT::CObjectType *t = new NLAIAGENT::CObjectType(new NLAIC::CIdentType(NLAIC::CIdentType::VoidType));                                     
+00185                                         a.push(CIdMethod(IObjetOp::getMethodIndexSize() + 9,0.0,NULL,t));
+00186                                         return a;
+00187                                 }
+00188                         }
+00189                         else if((*methodName) == constructor)
+00190                         {
+00191                                 NLAISCRIPT::CParam constructParam;
+00192                                 constructParam.push(NLAISCRIPT::COperandSimpleListOr(2,new NLAIC::CIdentType(DDigitalType::IdDDigitalType),new NLAIC::CIdentType(DDigitalType::IdDDigitalType)));
+00193                                 constructParam.push(NLAISCRIPT::COperandSimpleListOr(2,new NLAIC::CIdentType(DDigitalType::IdDDigitalType),new NLAIC::CIdentType(DDigitalType::IdDDigitalType)));
+00194                                 constructParam.push(NLAISCRIPT::COperandSimpleListOr(2,new NLAIC::CIdentType(DDigitalType::IdDDigitalType),new NLAIC::CIdentType(DDigitalType::IdDDigitalType)));
+00195                                 if(constructParam.eval(param) >= 0.0 )
+00196                                 {               
+00197                                         TQueue a;
+00198                                         //Type du retour du constructeur , c'est un void dont de type VoidType c'est à dire CIdentType::VoidType;
+00199                                         //CObjectType est un IObjectIA qui permet d'encapsuler un NLAIC::CIdentType c'est à dire un type.
+00200                                         //la variable NLAIC::CIdentType::VoidType est un static dans la class NLAIC::CIdentType.
+00201                                         NLAIAGENT::CObjectType *t = new NLAIAGENT::CObjectType(new NLAIC::CIdentType(NLAIC::CIdentType::VoidType));                                     
+00202                                         //CIdMethod est dans basicai.h elle va être documentee.
+00203                                         a.push(CIdMethod(IObjetOp::getMethodIndexSize() + 0,0.0,NULL,t));
+00204                                         return a;
+00205                                 }
+00206                         }
+00207                 }
+00208                 return IObjetOp::isMember(baseClass,methodName,p);
+00209         }
+

00094                 {
+00095                         return true;
+00096                 }
+

00149                 {
+00150                         return (double) sqrt(squareLength());
+00151                 }
+

00084                 {                               
+00085                         is.serial( _Value );
+00086                 }               
+

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                 }               
+

00203                 {
+00204                         return *this * *a;
+00205 
+00206                 }
+

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                 }
+

00183                 {
+00184                         return *this *= *a;
+00185 
+00186                 }
+

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                 }
+

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                 }
+

00194                 {
+00195                         NLMISC::CVectorD v = (NLMISC::CVectorD)((const IVector &)a).getValue();                 
+00196                         NLAILOGIC::CBoolType *x = new NLAILOGIC::CBoolType(_Value != v);                        
+00197                         return x;
+00198                 }
+

00194                 {
+00195                         return *this + *a;
+00196                 }
+

00180                 {
+00181                         IObjetOp *o = (IObjetOp *)clone();                      
+00182                         *o += a;
+00183                         return o;
+00184                 }
+

00174                 {
+00175                         return *this += *a;
+00176                 }
+

00166                 {
+00167                         NLMISC::CVectorD v = (NLMISC::CVectorD)((const IVector &)a).getValue();
+00168                         _Value += v;
+00169                         return *this;
+00170                 }
+

00198                 {
+00199                         return *this - *a;
+00200 
+00201                 }
+

00187                 {
+00188                         IObjetOp *o = (IObjetOp *)clone();                      
+00189                         *o -= a;
+00190                         return o;
+00191                 }
+

00178                 {
+00179                         return *this -= *a;
+00180 
+00181                 }
+

00173                 {
+00174                         NLMISC::CVectorD v = (NLMISC::CVectorD)((const IVector &)a).getValue();
+00175                         _Value -= v;
+00176                         return *this;
+00177                 }
+

00208                 {
+00209                         return *this / *a;
+00210 
+00211                 }
+

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                 }
+

00188                 {
+00189                         return *this /= *a;
+00190 
+00191                 }
+

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                 }       
+

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                 }
+

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                 }
+

00159                 {
+00160                         NLMISC::CVectorD v((NLMISC::CVectorD)((const IVector &)a).getValue());
+00161                         _Value = v;
+00162                         return *this;
+00163                 }
+

00135         {                                               
+00136                 if(a.getType() == getType() ) return isEqual(a);                        
+00137                 return false;
+00138         }               
+

00201                 {
+00202                         NLMISC::CVectorD v = (NLMISC::CVectorD)((const IVector &)a).getValue();                 
+00203                         NLAILOGIC::CBoolType *x = new NLAILOGIC::CBoolType(_Value == v);                        
+00204                         return x;
+00205                 }
+

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                 }
+

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                 }
+

00087                 {
+00088                         if(decRef() == 0) 
+00089                                         delete this;
+00090                 }
+

00257         {
+00258                 IBaseGroupType &param = (IBaseGroupType &)*p;
+00259 
+00260                 switch(methodTag - IObjetOp::getMethodIndexSize())
+00261                 {
+00262                 case 0:
+00263                         {
+00264                                 CIteratorContener i = param.getIterator();
+00265                                 const INombreDefine *o = (const INombreDefine *)i++;
+00266                                 x(o->getNumber());
+00267                                 o = (const INombreDefine *)i++;                         
+00268                                 y(o->getNumber());
+00269                                 o = (const INombreDefine *)i++;                         
+00270                                 z(o->getNumber());
+00271                                 IObjectIA::CProcessResult a;
+00272                                 a.ResultState = processIdle;
+00273                                 a.Result = NULL;
+00274                                 return a;
+00275                         }
+00276 
+00277                 case 1:
+00278                         {                               
+00279                                 DDigitalType *r = new DDigitalType(x());
+00280                                 r->incRef();
+00281                                 IObjectIA::CProcessResult a;
+00282                                 a.ResultState = processIdle;
+00283                                 a.Result = r;
+00284                                 return a;
+00285                         }                                               
+00286 
+00287                 case 2:
+00288                         {
+00289                                 
+00290                                 x(((const INombreDefine *)param.get())->getNumber());
+00291                                 IObjectIA::CProcessResult a;
+00292                                 a.ResultState = processIdle;
+00293                                 a.Result = NULL;
+00294                                 return a;
+00295                         }                       
+00296 
+00297                 case 3:
+00298                         {                               
+00299                                 DDigitalType *r = new DDigitalType(y());
+00300                                 r->incRef();
+00301                                 IObjectIA::CProcessResult a;
+00302                                 a.ResultState = processIdle;
+00303                                 a.Result = r;
+00304                                 return a;
+00305                         }                                               
+00306 
+00307                 case 4:
+00308                         {
+00309                                 y(((const INombreDefine *)param.get())->getNumber());
+00310                                 IObjectIA::CProcessResult a;
+00311                                 a.ResultState = processIdle;
+00312                                 a.Result = NULL;
+00313                                 return a;
+00314                         }                       
+00315 
+00316                 case 5:
+00317                         {                               
+00318                                 DDigitalType *r = new DDigitalType(z());
+00319                                 r->incRef();
+00320                                 IObjectIA::CProcessResult a;
+00321                                 a.ResultState = processIdle;
+00322                                 a.Result = r;
+00323                                 return a;
+00324                         }                                               
+00325 
+00326                 case 6:
+00327                         {
+00328                                 z(((const INombreDefine *)param.get())->getNumber());
+00329                                 IObjectIA::CProcessResult a;
+00330                                 a.ResultState = processIdle;
+00331                                 a.Result = NULL;
+00332                                 return a;
+00333                         }
+00334                 
+00335                 case 7:
+00336                         {
+00337                                 DDigitalType *r = new DDigitalType(squareLength());
+00338                                 r->incRef();
+00339                                 IObjectIA::CProcessResult a;
+00340                                 a.ResultState = processIdle;
+00341                                 a.Result = r;
+00342                                 return a;
+00343                         }
+00344 
+00345                 case 8:
+00346                         {
+00347                                 DDigitalType *r = new DDigitalType(length());
+00348                                 r->incRef();
+00349                                 IObjectIA::CProcessResult a;
+00350                                 a.ResultState = processIdle;
+00351                                 a.Result = r;
+00352                                 return a;
+00353                         }
+00354 
+00355                 case 9:
+00356                         {
+00357                                 unit();
+00358                                 IObjectIA::CProcessResult a;
+00359                                 a.ResultState = processIdle;
+00360                                 a.Result = NULL;
+00361                                 return a;
+00362                         }
+00363 
+00364                 default:
+00365                         return IObjetOp::runMethodeMember(methodTag,p);
+00366                         break;
+00367                 }
+00368         }
+

00237         {
+00239                 if(baseClassTag == 0)
+00240                 {
+00241                         return runMethodeMember(methodTag,p);
+00242                 }
+00244 /*              if(baseClassTag == (0+IObjetOp::getInheritedSize()) )
+00245                 {
+00246                         return runMethodeMember(methodTag,p);
+00247                 }
+00248 */
+00249                 return IObjectIA::runMethodeMember(baseClassTag,methodTag,p);
+00250 
+00251         }
+

00164         {
+00165                 std::string text;
+00166                 text = NLAIC::stringGetBuild("const CProcessResult &IObjectIA::runStep() note implementaited for the '%s' interface",(const char *)getType());
+00167                 throw NLAIE::CExceptionNotImplemented(text.c_str());
+00168                 return IObjectIA::ProcessNotComplit;
+00169         }
+

00079                 {       
+00080                         os.serial( _Value );
+00081                 }
+

00335         {
+00336                 std::string text;
+00337                 text = NLAIC::stringGetBuild("method 'sendMessage(%s,const IObjectIA &)' '%s' interface",name.getString(), (const char *)getType());
+00338                 throw NLAIE::CExceptionNotImplemented(text.c_str());
+00339                 return CProcessResult();
+00340         }
+

00343         {
+00344                 std::string text;
+00345                 text = NLAIC::stringGetBuild("method 'sendMessage(const IObjectIA &)' '%s' interface", (const char *)getType());
+00346                 throw NLAIE::CExceptionNotImplemented(text.c_str());
+00347                 return CProcessResult();
+00348         }
+

00329                 {
+00330                         if ( f.isReading() )
+00331                                 load( f );
+00332                         else
+00333                                 save( f );
+00334                 }
+

00199         {
+00200                 std::string text;
+00201                 text = NLAIC::stringGetBuild("Function void IObjectIA::setStaticMember(sint32,IObjectIA *) note implementaited for the '%s' interface",(const char *)getType());
+00202                 throw NLAIE::CExceptionNotImplemented(text.c_str());
+00203                 return false;
+00204         }
+

00269                 {
+00270                         return setStaticMember(getStaticMemberIndex(compName),change);
+00271                 }
+

00109                 {
+00110                         _Value = value;
+00111                 }               
+

00144                 {
+00145                         return _Value.x * _Value.x + _Value.y * _Value.y + _Value.z * _Value.z;
+00146                 }
+

00154                 {
+00155                         _Value.normalize();
+00156                 }
+

00129                 {
+00130                         _Value.x = u;
+00131                 }
+

00114                 {
+00115                         return _Value.x;
+00116                 }
+

00134                 {
+00135                         _Value.y = v;
+00136                 }
+

00119                 {
+00120                         return _Value.y;
+00121                 }
+

00139                 {
+00140                         _Value.z = w;
+00141                 }
+

00124                 {
+00125                         return _Value.z;
+00126                 }
+


Public Types
enum	TOpId { + op_add, +op_sub, +op_mul, +op_div, + + op_eq, +op_inf, +op_sup, +op_inf_eq, + + op_sup_eq, +op_not, +op_diff, +op_neg, + + op_last + + }
Public Member Functions
virtual TQueue	canProcessMessage (const IVarName &)
virtual const IBasicType *	clone () const=0
sint32	decRef ()
	Decrement the reference of an object.
virtual void	getDebugString (std::string &) const=0
virtual const std::string	getInfo ()
virtual std::string	getMethodeMemberDebugString (sint32, sint32) const
virtual sint32	getMethodIndexSize () const
virtual IObjetOp *	getNeg () const
const sint32 &	getRef () const
	get the refence count.
const IObjectIA *	getStaticMember (const IVarName &compName) const
virtual const IObjectIA *	getStaticMember (sint32) const
virtual sint32	getStaticMemberIndex (const IVarName &) const
virtual sint32	getStaticMemberSize () const
virtual const CIdentType &	getType () const=0
NLMISC::CVectorD	getValue () const
const NLMISC::CVectorD &	getValueRef () const
void	incRef ()
	Inc a reference. We use this when we have to conserve a pointer memeory for exemple in a list.
virtual void	init (IObjectIA *)
virtual sint32	isClassInheritedFrom (const IVarName &) const
virtual bool	isEqual (const IBasicObjectIA &a) const
virtual bool	isLocal ()
	If the result is true the object is loclal else its a representation of an object on the server. By the method return true.
virtual TQueue	isMember (const IVarName , const IVarName , const IObjectIA &) const
virtual bool	isTrue () const
	throw (NLAIE::CExceptionNotImplemented)
	IVector (NLMISC::IStream &is)
	IVector ()
	IVector (const IVector &value)
	IVector (const NLMISC::CVectorD &v)
	IVector (double x, double y, double z)
	Constructor.
double	length ()
virtual void	load (NLMISC::IStream &is)
virtual const IBasicType *	newInstance () const=0
virtual IObjetOp *	operator * (IObjetOp *a)
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp &	operator = (IObjetOp a)
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp *	operator! () const
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp *	operator!= (IObjetOp &a) const
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp *	operator+ (IObjetOp *a)
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp *	operator+ (const IObjetOp &a)
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp &	operator+= (IObjetOp *a)
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp &	operator+= (const IObjetOp &a)
	add the operater by anather.
virtual IObjetOp *	operator- (IObjetOp *a)
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp *	operator- (const IObjetOp &a)
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp &	operator-= (IObjetOp *a)
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp &	operator-= (const IObjetOp &a)
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp *	operator/ (IObjetOp *a)
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp &	operator/= (IObjetOp *a)
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp *	operator< (IObjetOp &) const
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp *	operator<= (IObjetOp &) const
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjectIA &	operator= (const IObjectIA &a)
bool	operator== (const IBasicObjectIA &classType) const
virtual IObjetOp *	operator== (IObjetOp &a) const
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp *	operator> (IObjetOp &) const
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp *	operator>= (IObjetOp &) const
	throw (NLAIE::CExceptionNotImplemented)
virtual void	release ()
	Release allow to release the pointer. The last release when the _Ref is nul delete the object.
virtual const CProcessResult &	run ()=0
virtual CProcessResult	runMethodeMember (sint32 index, IObjectIA *)
virtual CProcessResult	runMethodeMember (sint32, sint32, IObjectIA *)
virtual const CProcessResult &	runStep ()
virtual void	save (NLMISC::IStream &os)
virtual CProcessResult	sendMessage (const IVarName &, IObjectIA *)
virtual CProcessResult	sendMessage (IObjectIA *)
virtual void	serial (NLMISC::IStream &f) throw (NLMISC::EStream)
virtual bool	setStaticMember (sint32, IObjectIA *)
bool	setStaticMember (const IVarName &compName, IObjectIA *change)
void	setValue (NLMISC::CVectorD value)
double	squareLength ()
void	unit ()
void	x (const double u)
double	x () const
void	y (const double v)
double	y () const
void	z (const double w)
double	z () const
virtual	~IVector ()
Static Public Attributes
TProcessStatement	ProcessBuzzy = processBuzzy
TProcessStatement	ProcessEnd = processEnd
TProcessStatement	ProcessError = processError
TProcessStatement	ProcessIdle = processIdle
TProcessStatement	ProcessLocked = processLocked
CProcessResult	ProcessNotComplit = IObjectIA::CProcessResult(processNotComplete)
CProcessResult	ProcessRun = IObjectIA::CProcessResult()
Protected Attributes
NLMISC::CVectorD	_Value

NLAIAGENT::IVector Class Reference

Detailed Description

Public Types

Public Member Functions

Static Public Attributes

Protected Attributes

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Field Documentation