NeL: NLAILOGIC::CFirstOrderOperator 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                 };

00036         {
00037                 _Comment = NULL;
00038         }

00041         {
00042                 if ( c._Comment )
00043                 {
00044                         _Comment = new char[ strlen( c._Comment ) ];
00045                         strcpy( _Comment, c._Comment );
00046                 }
00047                 else
00048                         _Comment = NULL;
00049 
00050                 std::vector<IBaseAssert *>::const_iterator it_c = c._Concs.begin();
00051                 while ( it_c != c._Concs.end() )
00052                 {
00053                         _Concs.push_back( *it_c );
00054                         it_c++;
00055                 }
00056 
00057                 it_c = c._Conds.begin();
00058                 while ( it_c != c._Conds.end() )
00059                 {
00060                         _Conds.push_back( *it_c );
00061                         it_c++;
00062                 }
00063 
00064                 std::vector< std::vector<sint32> >::const_iterator it_li = c._PosVarsCond.begin();
00065                 while ( it_li != c._PosVarsCond.end() )
00066                 {
00067                         std::vector<sint32>::const_iterator it_i = (*it_li).begin();
00068                         _PosVarsCond.push_back( std::vector<sint32>() );
00069 
00070                         while ( it_i != (*it_li).end() )
00071                         {
00072                                 _PosVarsCond.back().push_back( *it_i ) ;
00073                                 it_i++;
00074                         }
00075                         it_li++;
00076                 }
00077 
00078                 it_li = c._PosVarsConc.begin();
00079                 while ( it_li != c._PosVarsConc.end() )
00080                 {
00081                         std::vector<sint32>::const_iterator it_i = (*it_li).begin();
00082                         _PosVarsConc.push_back( std::vector<sint32>() );
00083 
00084                         while ( it_i != (*it_li).end() )
00085                         {
00086                                 _PosVarsConc.back().push_back( *it_i ) ;
00087                                 it_i++;
00088                         }
00089                         it_li++;
00090                 }
00091         }

00110         {
00111                 for ( sint32 i = 0; i < (sint32) _Vars.size() ; i++ )
00112                         _Vars[ i ]->release();
00113         }

00160         {
00161                 if ( pattern->getAssert() )
00162                 {
00163                         std::vector<sint32> pos_Vars;
00164                         compileFactPattern( pattern, _Conds, pos_Vars);
00165 
00166                         pattern->getAssert()->addInput( this );
00167                         _Concs.push_back( pattern->getAssert() );
00168                         _PosVarsConc.push_back( pos_Vars );
00169                 }
00170         }

00146         {
00147                 if ( pattern->getAssert() )
00148                 {
00149                         std::vector<sint32> pos_Vars;
00150                         compileFactPattern( pattern, _Conds, pos_Vars);
00151 
00152 //                      pattern->getAssert()->addClause( this, pos_Vars );
00153                         _Conds.push_back( pattern->getAssert() );
00154                         _PosVarsCond.push_back( pos_Vars );
00155 
00156                 }
00157         }

00314         {
00315                 CValueSet *unified = unifyBackward( facts );
00316                 std::list<CFact *> *result = new std::list<CFact *>;
00317                 for (sint32 i = 0; i < (sint32) _Conds.size(); i++ )
00318                 {
00319                         CFact *tmp = buildFromVars( _Conds[i], _PosVarsCond[i], unified );
00320                         result->push_back( tmp );
00321 #ifdef NL_DEBUG
00322                         std::string buffer;
00323                         tmp->getDebugString(buffer);
00324 #endif
00325                 }
00326                 unified->release();
00327                 return result;
00328         }

00304         {
00305                 CFact *result = new CFact( assert);     // TODO:: pas besoin du nombre dans ce constructeur puisqu'on a l'assert
00306                 for (sint32 i = 0; i < (sint32) pl.size() ; i++ )
00307                 {
00308                         result->setValue( i, (*vars)[ pl[i] ] );
00309                 }
00310                 return result;
00311         }

00351         {
00352                 return TQueue();
00353         }

00487         {
00488                 CFirstOrderOperator *clone = new CFirstOrderOperator( *this );
00489                 return clone;
00490         }

00116         {
00117                 // Recherche si variables à ajouter
00118                 std::vector<IBaseVar *> *vars_pattern = fp->getVars();
00119                 if ( vars_pattern )
00120                 {
00121                         std::vector<IBaseVar *>::iterator it_cond = vars_pattern->begin();
00122                         while ( it_cond != vars_pattern->end() )
00123                         {
00124                                 sint32 id_var = getVarPos( *it_cond );
00125                                 if ( id_var != -1 )
00126                                 {
00127                                         pos_Vars.push_back( id_var );
00128                                 }
00129                                 else
00130                                 {
00131                                         _Vars.push_back( (IBaseVar *)(*it_cond)->clone() );
00132                                         pos_Vars.push_back( _Vars.size() - 1);
00133                                 }
00134                                 it_cond++;
00135                         }
00136                 }
00137 
00138                 for ( sint32 i = 0; i < (sint32) vars_pattern->size(); i++ )
00139                 {
00140                         (*vars_pattern)[i]->release();
00141                 }
00142                 delete vars_pattern;
00143         }

00094                 {
00095                         return --_Ref;
00096                 }

00331         {
00332                 CValueSet *unified = unifyForward( facts );
00333 
00334 #ifdef NL_DEBUG
00335                 std::string buf;
00336                 unified->getDebugString( buf );
00337 #endif
00338 
00339                 std::list<CFact *> *result = new std::list<CFact *>;
00340                 for (sint32 i = 0; i < (sint32) _Concs.size(); i++ )
00341                 {
00342                         CFact *tmp = buildFromVars( _Concs[i], _PosVarsConc[i], unified );
00343                         result->push_back( tmp );
00344 
00345 #ifdef NL_DEBUG
00346                         std::string buffer;
00347                         tmp->getDebugString(buffer);
00348 #endif
00349                 }
00350                 unified->release();
00351                 return result;
00352         }

00221         {
00222                 return NULL;            
00223         }

00212         {
00213                 for (sint32 i = 0; i < (sint32) l.size() ; i++ )
00214                 {
00215                         if ( (*(l[i])) == a )
00216                                 pos.push_back(i);
00217                 }
00218         }

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

00507         {
00508                 txt += "Operator:\n   -Preconditions:\n";
00509                 if ( _Comment )
00510                 {
00511                         txt += _Comment;
00512                         txt += "\n";
00513                 }
00514 
00515                 std::vector<IBaseAssert *>::const_iterator it_a = _Conds.begin();
00516                 std::vector<std::vector<sint32> >::const_iterator it_p = _PosVarsCond.begin();
00517                 while ( it_a != _Conds.end() )
00518                 {
00519                         std::string buf;
00520                         (*it_a)->getDebugString(buf);
00521                         txt += "    ( ";
00522                         txt += buf;
00523                         for (sint32 i = 0; i < (sint32) (*it_p).size(); i++ )
00524                         {
00525                                 txt += _Vars[ (*it_p)[i] ]->getName().getString();
00526                                 txt += " ";
00527                         }
00528                         txt += ")\n";
00529 
00530                         it_a++;
00531                         it_p++;
00532                 }
00533 
00534                 txt += "  -Postconditions:\n";
00535                 it_a = _Concs.begin();
00536                 it_p = _PosVarsConc.begin();
00537                 while ( it_a != _Concs.end() )
00538                 {
00539                         std::string buf;
00540                         (*it_a)->getDebugString(buf);
00541                         txt += "    ( ";
00542                         txt += buf;
00543                         for (sint32 i = 0; i < (sint32) (*it_p).size(); i++ )
00544                         {
00545                                 txt += _Vars[ (*it_p)[i] ]->getName().getString();
00546                                 txt += " ";
00547                         }
00548                         txt += ")\n";
00549 
00550                         it_a++;
00551                         it_p++;
00552                 }
00553         }

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         }

00094         {
00095                 return IObjectIA::getMethodIndexSize() + op_last;
00096         }

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

00175         {
00176                 std::vector<sint32>::iterator it_conc = _PosVarsConc[ no_conc ].begin();
00177                 while ( it_conc != _PosVarsConc[ no_conc ].end() )
00178                 {
00179                         std::vector<sint32>::iterator it_cond = _PosVarsCond[ no_cond ].begin();
00180                         while ( it_cond != _PosVarsCond[ no_cond ].end() )
00181                         {
00182                                 if ( (*it_conc) == (*it_cond) )
00183                                 {
00184                                         cond_pos.push_back( *it_cond );
00185                                 }
00186                                 it_cond++;
00187                         }
00188                         it_conc++;
00189                 }
00190         }

00194         {
00195                 std::vector<sint32>::iterator it_cond = _PosVarsCond[ no_cond ].begin();
00196                 while ( it_cond != _PosVarsCond[ no_cond ].end() )
00197                 {
00198                         std::vector<sint32>::iterator it_conc = _PosVarsConc[ no_conc ].begin();
00199                         while ( it_conc != _PosVarsConc[ no_conc ].end() )
00200                         {
00201                                 if ( (*it_cond) == (*it_conc) )
00202                                 {
00203                                         conc_pos.push_back( *it_conc );
00204                                 }
00205                                 it_conc++;
00206                         }
00207                         it_cond++;
00208                 }
00209         }

00098         {
00099                 return _Concs;
00100         }

00093         {
00094                 return _Conds;
00095         }

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         }

00576         {
00577                 return IdCFirstOrderOperator;
00578         }

00081                 {
00082                         _Ref ++;
00083                 }

00117         {
00118                 
00119         }

00247         {
00248                 return -1;
00249         }

00566         {
00567                 return false;           
00568         }

00556         {
00557                 return false;
00558         }

00357         {
00358                 return true;
00359         }

00207         {               
00208                 static CStringVarName send(_SEND_);
00209                 static CStringVarName constructor(_CONSTRUCTOR_);
00210                 static CStringVarName run(_RUN_);
00211                 static CStringVarName statM("GetStaticMember");
00212 
00213                 if(*methodName == send)
00214                 {
00215                         TQueue r;                       
00216                         CObjectType *c = new CObjectType(new NLAIC::CIdentType(NLAIC::CIdentType::VoidType));
00217                         r.push(CIdMethod(0,0.0,NULL,c));
00218                         return r;
00219                 }
00220                 else
00221                 if(*methodName == constructor && !((const NLAISCRIPT::CParam &)param).size())
00222                 {
00223                         TQueue r;
00224                         CObjectType *c = new CObjectType(new NLAIC::CIdentType(NLAIC::CIdentType::VoidType));
00225                         r.push(CIdMethod(1,0.0,NULL,c));
00226                         return r;
00227                 }
00228                 else
00229                 if(*methodName == run && !((const NLAISCRIPT::CParam &)param).size())
00230                 {
00231                         TQueue r;
00232                         CObjectType *c = new CObjectType(new NLAIC::CIdentType(NLAIC::CIdentType::VoidType));
00233                         r.push(CIdMethod(2,0.0,NULL,c));
00234                         return r;                       
00235                 }
00236                 if(*methodName == statM && ((const NLAISCRIPT::CParam &)param).size())
00237                 {
00238                         TQueue r;
00239                         CObjectType *c = new CObjectType(new NLAIC::CIdentType(*IAgent::IdAgent));
00240                         r.push(CIdMethod(3,0.0,NULL,c));
00241                         return r;                       
00242                 }
00243                 return TQueue();
00244         }

00571         {
00572                 return false;
00573         }

00592         {               
00593                 std::list<CFact *> *facts = new std::list<CFact *>;
00594                 for (sint32 i = 0; i < (sint32) _Conds.size(); i++ )
00595                 {
00596                         std::list<CFact *> *fa = fb->getAssertFacts( _Conds[i] );
00597                         while ( fa->size() )
00598                         {
00599                                 facts->push_back( fa->front() );
00600                                 fa->pop_front();
00601                         }
00602                         delete fa;
00603                 }
00604                 std::list<CFact *> *res = propagate( *facts );
00605                 bool is_valid = !res->empty();
00606                 while ( res->size() )
00607                 {
00608 #ifdef NL_DEBUG
00609                         std::string buffer;
00610                         res->front()->getDebugString( buffer );
00611 #endif
00612                         res->front()->release();
00613                         res->pop_front();
00614                 }
00615                 delete res;
00616 
00617                 while ( facts->size() )
00618                 {
00619                         facts->front()->release();
00620                         facts->pop_front();     
00621                 }
00622                 delete facts;
00623 
00624                 return is_valid;
00625         }

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                 }

00493         {
00494                 CFirstOrderOperator *instance = new CFirstOrderOperator;
00495                 return instance;
00496         }

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                 }

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                 }

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

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                 }

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

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                 }

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

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                 }

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

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                 }

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                 }

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

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                 }

00581         {
00582                 return false;
00583         }

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                 }

00628         {
00629                 return 0.0;
00630         }

00356         {
00357                 std::list<CFact *> *conflicts = new std::list<CFact *>;
00358                 std::list< CValueSet *> liaisons;
00359                 CValueSet *empty = new CValueSet( _Vars.size() );
00360                 liaisons.push_back( empty );
00361 
00362                 std::list<CFact *>::iterator it_f = facts.begin();
00363                 while ( it_f != facts.end() )
00364                 {
00365                         std::vector<sint32> pos_asserts;
00366                         getAssertPos( (*it_f)->getAssert() , _Conds, pos_asserts);
00367                         for (sint32 i = 0; i < (sint32) pos_asserts.size(); i++ )
00368                         {
00369                                 std::list<CValueSet *> *links = propagate( liaisons, *it_f, _PosVarsCond[ pos_asserts[i] ] );
00370                                 if ( links )
00371                                 {
00372                                         while ( links->size() )
00373                                         {
00374                                                 for (sint32 i = 0; i < (sint32) _Concs.size(); i++ )
00375                                                 {
00376                                                         CFact *r = buildFromVars( _Concs[i], _PosVarsConc[i], links->front() );
00377 #ifdef NL_DEBUG
00378                                                         std::string buf;
00379                                                         r->getDebugString( buf );
00380 #endif
00381                                                         // Tests if the fact is already in the conflicts list
00382                                                         bool found = false;
00383                                                         std::list<CFact *>::iterator it_c = conflicts->begin();
00384                                                         while ( ! found && it_c != conflicts->end() )
00385                                                         {
00386                                                                 found = (**it_c) == *r;
00387                                                                 it_c++;
00388                                                         }
00389                                                         if ( !found )
00390                                                         {
00391 #ifdef NL_DEBUG
00392                                                                 std::string buf;
00393                                                                 r->getDebugString( buf );
00394 #endif
00395                                                                 conflicts->push_back( r );
00396                                                         }
00397                                                 }
00398                                                 links->front()->release();
00399                                                 links->pop_front();
00400                                         }
00401                                         delete links;
00402                                 }
00403                         }
00404                         it_f++;
00405                 }
00406 
00407                 while ( liaisons.size() )
00408                 {
00409                         liaisons.front()->release();
00410                         liaisons.pop_front();
00411                 }
00412 
00413                 return conflicts;
00414         }

00430         {
00431                 std::list<CValueSet *> *conflits = new std::list<CValueSet *>;
00432                 std::list<CValueSet *> buf_liaisons;
00433                 // Pour chaque liaison...
00434                 std::list< CValueSet *>::iterator it_l = liaisons.begin();
00435                 
00436                 while ( it_l != liaisons.end() )
00437                 {
00438 
00439                         CValueSet *l = *it_l;
00440 #ifdef NL_DEBUG
00441                         std::string buf;
00442                         l->getDebugString( buf );
00443 #endif
00444 
00445                         CValueSet *result = unifyLiaison( l, fact, pos_vals );
00446                         if ( result )
00447                         {
00448 #ifdef NL_DEBUG
00449                                 std::string buf;
00450                                 result->getDebugString( buf );
00451 #endif
00452 
00453                                 if ( result->undefined() == 0 )
00454                                 {
00455                                         conflits->push_back( result );
00456                                 }
00457                                 else 
00458                                         buf_liaisons.push_back( result );
00459                         }
00460                         it_l++;
00461                 }
00462 
00463                 while ( buf_liaisons.size() )
00464                 {
00465                         liaisons.push_back( buf_liaisons.front() );
00466                         buf_liaisons.pop_front();
00467                 }
00468 
00469                 return conflits;
00470         }

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

00561         {               
00562                 return IObjectIA::ProcessRun;
00563         }

00267         {
00268                 
00269                 switch(id)
00270                 {
00271                 case 0:
00272                         {
00273                                 IMessageBase *msg;
00274 
00275                                 IPerformative *p;
00276                                 msg = (IMessageBase *)((IBaseGroupType *)a)->pop();
00277                                 //this->incRef();
00278                                 msg->setReceiver(this);
00279                                 p = (IPerformative *)((IBaseGroupType *)a)->pop();
00280                                 msg->setPerformatif((IMessageBase::TPerformatif)(sint)p->getNumber());
00281                                 p->release();
00282                                 if(((IBaseGroupType *)a)->size())
00283                                 {                                       
00284                                         CStringType *name = (CStringType *)((IBaseGroupType *)a)->pop();
00285                                         IObjectIA::CProcessResult r = sendMessage(name->getStr(),msg);
00286                                         name->release();
00287                                         return r;
00288                                         
00289                                 }                               
00290                                 return sendMessage(msg);
00291                         }                       
00292                         break;
00293                 case 1:                 
00294                         break;
00295                 case 2:
00296                         return run();
00297                         break;
00298 
00299                 case 3:
00300                         {
00301                                 CProcessResult r;
00302                                 NLAIAGENT::IBaseGroupType *param = (NLAIAGENT::IBaseGroupType *)a;
00303                                 r.Result =      (IObjectIA *)getStaticMember((sint)((NLAIAGENT::INombreDefine *)param->get())->getNumber());
00304                                 r.Result->incRef();
00305                                 return r;
00306                         }
00307                 }
00308                 return CProcessResult();
00309         }

00258         {
00259                 /*char text[2048*8];
00260                 sprintf(text,"method  runMethodeMember(sint32 h, sint32 id,const IObjectIA &) not implemented for the '%s' interface",(const char *)getType());
00261                 throw NLAIE::CExceptionNotImplemented(text);
00262                 return CProcessResult();*/
00263                 return IObjectIA::runMethodeMember(id,a);
00264         }

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         }

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                 }

00079         {
00080                 if ( _Comment )
00081                         delete[] _Comment;
00082 
00083                 if ( c ) 
00084                 {
00085                         _Comment = new char[ strlen( c ) ];
00086                         strcpy( _Comment, c );
00087                 }
00088                 else
00089                         _Comment = NULL;
00090         }

00151         {
00152                 if ( _Goal )
00153                         _Goal->release();
00154 
00155                 _Goal = goal;
00156 
00157                 if ( goal != NULL )
00158                         _Goal->incRef();
00159         }

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                 }

00473         {
00474                 std::list<CFact *> *preconds = backward( facts );
00475 
00476                 std::list<CFact *>::iterator it_f = preconds->begin();
00477                 while ( it_f != preconds->end() )
00478                 {
00479                         ( (CFirstOrderAssert *)(*it_f)->getAssert() )->backward( *it_f );
00480                         it_f++;
00481                 }
00482                 return NULL;
00483         }

00586         {
00587                 return 0.0;
00588         }

00226         {
00227                 CValueSet *unified = new CValueSet( _Vars.size() );
00228                 std::list<CFact *>::iterator it_f = facts.begin();
00229                 while ( it_f != facts.end() )
00230                 {
00231                         std::vector<sint32> pos_assert;
00232                         getAssertPos( (*it_f)->getAssert(), _Concs, pos_assert );
00233                         for (sint32 pos = 0; pos < (sint32) pos_assert.size(); pos++)
00234                         {
00235                                 for ( sint32 ivar = 0; ivar < (sint32) _PosVarsConc[ pos_assert[pos] ].size(); ivar++ )
00236                                 {
00237                                         sint32 l_pos = _PosVarsConc[ pos_assert[pos] ][ivar];
00238 
00239                                         IObjectIA *l_val = (*unified)[ l_pos ]; 
00240                                         IObjectIA *r_val = (**it_f)[ ivar ];
00241 
00242                                         if ( !l_val )
00243                                         {
00244                                                 if ( r_val )
00245                                                 {
00246                                                         unified->setValue( l_pos, r_val );
00247                                                 }
00248                                         }
00249                                         else
00250                                         {
00251                                                 if ( r_val && ( l_val != r_val ) )
00252                                                 {
00253                                                         unified->release();
00254                                                         return NULL;
00255                                                 }
00256                                         }
00257                                 }
00258                         }
00259                         it_f++;
00260                 }
00261                 return unified;
00262         }

00265         {
00266                 CValueSet *unified = new CValueSet( _Vars.size() );
00267                 std::list<CFact *>::iterator it_f = facts.begin();
00268                 while ( it_f != facts.end() )
00269                 {
00270                         std::vector<sint32> pos_assert;
00271                         getAssertPos( (*it_f)->getAssert(), _Conds, pos_assert );
00272                         for (sint32 pos = 0; pos < (sint32) pos_assert.size(); pos++)
00273                         {
00274                                 for ( sint32 ivar = 0; ivar < (sint32) _PosVarsCond[ pos_assert[pos] ].size(); ivar++ )
00275                                 {
00276                                         sint32 l_pos = _PosVarsCond[ pos_assert[pos] ][ivar];
00277 
00278                                         IObjectIA *l_val = (*unified)[ l_pos ]; 
00279                                         IObjectIA *r_val = (**it_f)[ ivar ];
00280 
00281                                         if ( !l_val )
00282                                         {
00283                                                 if ( r_val )
00284                                                 {
00285                                                         unified->setValue( l_pos, r_val );
00286                                                 }
00287                                         }
00288                                         else
00289                                         {
00290                                                 if ( r_val && ( l_val != r_val ) )
00291                                                 {
00292                                                         unified->release();
00293                                                         return NULL;
00294                                                 }
00295                                         }
00296                                 }
00297                         }
00298                         it_f++;
00299                 }
00300                 return unified;
00301         }

00417         {
00418                 CValueSet *result;
00419 
00420                 if ( (result = fp->unify( vals, pos_vals )) )
00421                         return result;
00422                 else
00423                 {
00424                         delete result;
00425                         return NULL;
00426                 }
00427         }

 NLAIC::CIdentType( "FirstOrderOperator", NLAIC::CSelfClassFactory(CFirstOrderOperator()), 
                NLAIC::CTypeOfObject::tLogic,
                NLAIC::CTypeOfOperator::opAdd )


IObjectIA base class method;
virtual sint32	getMethodIndexSize () const
virtual TQueue	IObjetOp::isMember (const IVarName , const IVarName , const IObjectIA &) const
virtual CProcessResult	IObjetOp::runMethodeMember (sint32 index, IObjectIA *)
[NOHEADER]
virtual IObjetOp &	neg ()
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp &	operator *= (const IObjetOp &)
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp &	operator+= (const IObjetOp &)
	add the operater by anather.
virtual IObjetOp &	operator-= (const IObjetOp &)
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp &	operator/= (const IObjetOp &)
	throw (NLAIE::CExceptionNotImplemented)
[NOHEADER]
virtual IObjetOp *	operator * (const IObjetOp &)
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp *	operator+ (const IObjetOp &)
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp *	operator- (const IObjetOp &)
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp *	operator/ (const IObjetOp &)
	throw (NLAIE::CExceptionNotImplemented)
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
void	addPostcondition (CFactPattern *)
	Adds a first order logic postcondition to the operator.
void	addPrecondition (CFactPattern *)
	Adds a first order logic precondition to the operator.
std::list< CFact * > *	backward (std::list< CFact * > &)
	Returns the result of backarding a list of facts through the operator.
std::list< CFactPattern * > *	backward (CFactPattern *)
	Gives the precondition for a CFact in the postconditions.
virtual TQueue	canProcessMessage (const IVarName &)
	CFirstOrderOperator (const CFirstOrderOperator &)
	CFirstOrderOperator ()
virtual const NLAIC::IBasicType *	clone () const
sint32	decRef ()
	Decrement the reference of an object.
virtual void	failure (IBaseOperator *)
virtual void	failure ()
std::list< CFact * > *	forward (std::list< CFact * > &)
	Returns the conclusions of the operator for given preconditions facts.
std::list< CFactPattern * > *	forward (CFactPattern *)
	Gives the postcondition for a CFact in the preconditions.
virtual void	getDebugString (std::string &) const
virtual const std::string	getInfo ()
virtual std::string	getMethodeMemberDebugString (sint32, sint32) const
virtual IObjetOp *	getNeg () const
const std::vector< IBaseAssert * > &	getPostCondAsserts () const
const std::vector< IBaseAssert * > &	getPrecondAsserts () 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
const NLAIC::CIdentType &	getType () 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=0
bool	isEqual (const NLAIAGENT::IBasicObjectIA &a) const
virtual bool	isEqual (const CFirstOrderOperator &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
	Returns true if the preconditions are validated.
virtual bool	isValid (CFactBase *)
	Asks wether the operator's preconditions are validated,.
virtual void	load (NLMISC::IStream &is)
virtual const NLAIC::IBasicType *	newInstance () const
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 &) const
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp *	operator+ (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 *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)
bool	operator== (const IBasicObjectIA &classType) const
virtual IObjetOp *	operator== (IObjetOp &) const
	throw (NLAIE::CExceptionNotImplemented)
virtual bool	operator== (CFirstOrderOperator *)
virtual IObjetOp *	operator> (IObjetOp &) const
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp *	operator>= (IObjetOp &) const
	throw (NLAIE::CExceptionNotImplemented)
virtual float	priority () const
	Priority of the operator.
std::list< CFact * > *	propagate (std::list< CFact * > &)
	Propagates facts through the operator and network of asserts/ operators.
virtual void	release ()
	Release allow to release the pointer. The last release when the _Ref is nul delete the object.
virtual const NLAIAGENT::IObjectIA::CProcessResult &	run ()
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)
void	setComment (char *)
	Sets teh comment for the operator.
virtual void	setGoal (IBaseAssert *)
	Sets the goals the operator tries to achieve.
virtual bool	setStaticMember (sint32, IObjectIA *)
bool	setStaticMember (const IVarName &compName, IObjectIA *change)
virtual void	success (IBaseOperator *)
virtual void	success ()
std::list< CFact * > *	test (std::list< CFact * > &)
virtual float	truthValue () const
	Returns a value in [0,1].
	~CFirstOrderOperator ()
Static Public Attributes
const NLAIC::CIdentType	IdCFirstOrderOperator
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 Member Functions
CFact *	buildFromVars (IBaseAssert , std::vector< sint32 > &, CValueSet )
sint32	CFirstOrderOperator::getVarPos (IBaseVar *var)
	Returns the pos of a vraiables in the operator's vars table, -1 if not found.
void	compileFactPattern (CFactPattern , std::vector< IBaseAssert > &, std::vector< sint32 > &)
	Pos of a postcondition pattern's vars in the operator's vars tableTransforms a CFactPattern in an assert and a list of variable positions in the operator.
void	getAssertPos (IBaseAssert , std::vector< IBaseAssert > &, std::vector< sint32 > &)
void	getPosListBackward (sint32, sint32, std::vector< sint32 > &)
void	getPosListForward (sint32, sint32, std::vector< sint32 > &)
std::list< CValueSet * > *	propagate (std::list< CValueSet * > &, CValueSet *, std::vector< sint32 > &)
	Forward chaining.
CValueSet *	unifyBackward (std::list< CFact * > &)
CValueSet *	unifyForward (std::list< CFact * > &)
CValueSet *	unifyLiaison (const CValueSet , CValueSet , std::vector< sint32 > &)
	Tries to unify an instaciation of the operator's variables with a new CFact.
Protected Attributes
char *	_Comment
	Description of the operator.
std::vector< IBaseAssert * >	_Concs
	Postconditions asserts.
std::vector< IBaseAssert * >	_Conds
	Preconditions asserts.
IBaseAssert *	_Goal
std::vector< std::vector< sint32 > >	_PosVarsConc
	Pos of a precondition pattern's vars in the operator's vars table.
std::vector< std::vector< sint32 > >	_PosVarsCond
	Variables of the operator.
std::vector< IBaseVar * >	_Vars

NLAILOGIC::CFirstOrderOperator Class Reference

IObjectIA base class method;

[NOHEADER]

[NOHEADER]

Public Types

Public Member Functions

Static Public Attributes

Protected Member Functions

Protected Attributes

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Field Documentation