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