00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020 #include "nel/ai/logic/valueset.h"
00021 #include "nel/ai/logic/var.h"
00022 #include "nel/ai/logic/boolval.h"
00023 #include "nel/ai/logic/clause.h"
00024 #include "nel/ai/logic/ai_assert.h"
00025
00026 namespace NLAILOGIC
00027 {
00028 using namespace NLAIAGENT;
00029
00030 const TProcessStatement CValueSet::state = processIdle;
00031
00032 CValueSet::CValueSet()
00033 {
00034 _NbValues = 0;
00035 _Values = NULL;
00036 }
00037
00039 CValueSet::CValueSet(sint32 size)
00040 {
00041 _NbValues = size;
00042 _Values = new IObjectIA *[ _NbValues ];
00043
00044 for ( sint32 i = 0; i < _NbValues; i++ )
00045 {
00046 _Values[ i ] = NULL;
00047 }
00048 }
00049
00051 CValueSet::CValueSet(const CValueSet &cp)
00052 {
00053 _NbValues = cp._NbValues;
00054
00055 _Values = new IObjectIA *[ _NbValues ];
00056
00057 for ( sint32 i = 0; i < _NbValues; i++ )
00058 {
00059 _Values[i] = (IObjectIA *) cp._Values[i];
00060
00061 if ( _Values[i] )
00062 _Values[i]->incRef();
00063 }
00064 }
00065
00067 CValueSet::CValueSet(std::vector<IBaseVar *> &vars)
00068 {
00069 _NbValues = vars.size();
00070
00071 _Values = new IObjectIA *[ _NbValues ];
00072
00073 for (sint32 i = 0; i < _NbValues; i++ )
00074 {
00075 _Values[ i ] = vars[i]->getValue();
00076
00077 if ( _Values[i] )
00078 _Values[i]->incRef();
00079 }
00080 }
00081
00082
00083
00084
00087 CValueSet::CValueSet(CValueSet *vals, std::vector<sint32> &pos)
00088 {
00089 _NbValues = pos.size();
00090
00091 _Values = new IObjectIA *[ _NbValues ];
00092
00093 for (sint32 i = 0; i < _NbValues; i++ )
00094 {
00095 _Values[ i ] = NULL;
00096 }
00097
00098 std::vector<sint32>::iterator it_pos = pos.begin();
00099 sint32 index = 0;
00100 while ( it_pos != pos.end() )
00101 {
00102 _Values[ index ] = vals->_Values[ *it_pos ];
00103 it_pos++;
00104 index++;
00105 }
00106 }
00107
00109 CValueSet::CValueSet(sint32 size, std::list<IObjectIA *> *vals, std::vector<sint32> &pos)
00110 {
00111 _NbValues = size;
00112
00113 _Values = new IObjectIA *[ _NbValues ];
00114
00115 for (sint32 i = 0; i < _NbValues; i++ )
00116 {
00117 _Values[ i ] = NULL;
00118 }
00119
00120 std::list<IObjectIA *>::iterator it_val = vals->begin();
00121 std::vector<sint32>::iterator it_pos = pos.begin();
00122
00123 while ( it_val != vals->end() && it_pos != pos.end() )
00124 {
00125 _Values[ *it_pos ] = *it_val;
00126 (*it_val)->incRef();
00127 it_val++;
00128 it_pos++;
00129 }
00130 }
00131
00132 CValueSet::~CValueSet()
00133 {
00134 for ( sint32 i = 0; i < _NbValues; i++ )
00135 if ( _Values[i] )
00136 _Values[i]->release();
00137 delete[] _Values;
00138 }
00139
00140 void CValueSet::setValue(sint32 pos, IObjectIA *obj)
00141 {
00142 _Values[pos] = obj;
00143 if ( obj )
00144 obj->incRef();
00145 }
00146
00147
00148
00149
00150
00151
00155 CValueSet *CValueSet::unify(const CValueSet *un) const
00156 {
00157 CValueSet *result = new CValueSet( _NbValues );
00158 int i;
00159 for( i = 0; i < _NbValues; i++ )
00160 {
00161 result->_Values[i] = _Values[i];
00162 if ( _Values[i] )
00163 _Values[i]->incRef();
00164
00165 }
00166
00167 for (i = 0; i < _NbValues ; i++ )
00168 {
00169 IObjectIA *x_val = result->_Values[ i ];
00170 IObjectIA *y_val = un->_Values[ i ];
00171
00172
00173
00174
00175 if ( x_val && y_val )
00176 {
00177
00178 if ( (*x_val) == ( *y_val ) )
00179 {
00180
00181 }
00182 else
00183 {
00184 result->release();
00185 return NULL;
00186 }
00187
00188 }
00189 else
00190 {
00191 if ( y_val )
00192 {
00193 result->_Values[i] = y_val;
00194 result->_Values[i]->incRef();
00195 }
00196 }
00197 }
00198 return result;
00199 }
00200
00202 CValueSet *CValueSet::unify(std::list<IObjectIA *> *vals, std::vector<sint32> &pos_vals) const
00203 {
00204 CValueSet *result = new CValueSet( _NbValues );
00205 for (sint32 i = 0; i < _NbValues; i++ )
00206 {
00207 result->_Values[i] = _Values[i];
00208 if ( _Values[i] )
00209 _Values[i]->incRef();
00210
00211 }
00212
00213 std::list<IObjectIA *>::iterator it_val = vals->begin();
00214 std::vector<sint32>::iterator it_pos = pos_vals.begin();
00215
00216
00217
00218 #ifdef NL_DEBUG
00219 std::string buf;
00220 this->getDebugString(buf);
00221 std::string buf2;
00222 CValueSet tmp(_NbValues, vals, pos_vals);
00223 tmp.getDebugString(buf2);
00224 #endif
00225
00226
00227
00228
00229 while ( it_val != vals->end() && it_pos != pos_vals.end() )
00230 {
00231 sint32 pos = *it_pos;
00232 IObjectIA *l_val = _Values[ pos ];
00233
00234 if ( !l_val || ( (*l_val) == ( **it_val ) ) )
00235 {
00236
00237
00238 result->_Values[ pos ] = *it_val;
00239 result->_Values[ pos ]->incRef();
00240 }
00241 else
00242 {
00243
00244
00245 delete result;
00246 return NULL;
00247 }
00248 it_val++;
00249 it_pos++;
00250
00251 }
00252
00253 return result;
00254 }
00255
00256 CValueSet *CValueSet::unify(CValueSet *vals, std::vector<sint32> &pos_vals) const
00257 {
00258 CValueSet *result = new CValueSet( _NbValues );
00259 int i;
00260 for ( i = 0; i < _NbValues; i++ )
00261 {
00262 result->_Values[i] = _Values[i];
00263 if ( _Values[i] )
00264 _Values[i]->incRef();
00265
00266 }
00267
00268 for (i = 0; i < (sint32) pos_vals.size(); i++ )
00269 {
00270 sint32 pos = pos_vals[i];
00271 IObjectIA *l_val = _Values[ pos ];
00272 IObjectIA *r_val = (*vals)[i];
00273
00274
00275 if ( !l_val || ( (*l_val) == ( *r_val ) ) )
00276 {
00277
00278
00279 if ( !l_val )
00280 {
00281 result->_Values[ pos ] = r_val;
00282 if ( (*vals)[i] )
00283 result->_Values[ pos ]->incRef();
00284 }
00285 }
00286 else
00287 {
00288
00289
00290 result->release();
00291 return NULL;
00292 }
00293 }
00294 return result;
00295 }
00296
00297
00298 bool CValueSet::operator==(CValueSet *cp)
00299 {
00300 if( cp->_NbValues != _NbValues )
00301 return false;
00302
00303 for ( sint32 i = 0; i < _NbValues; i++ )
00304 if ( cp->_Values[i] != _Values[i] )
00305 return false;
00306 return true;
00307 }
00308
00309 IObjectIA *CValueSet::operator[](sint32 pos)
00310 {
00311 if ( pos <= _NbValues )
00312 return _Values[pos];
00313 else
00314 return NULL;
00315 }
00316
00317 IObjectIA *CValueSet::getValue(sint32 pos)
00318 {
00319 if ( pos <= _NbValues )
00320 return _Values[pos];
00321 else
00322 return NULL;
00323 }
00324
00326 sint32 CValueSet::undefined() const
00327 {
00328 sint32 nb_undef = _NbValues;
00329 for ( sint32 i = 0; i < _NbValues; i++ )
00330 if ( _Values[i] != NULL )
00331 nb_undef--;
00332 return nb_undef;
00333 }
00334
00335 sint32 CValueSet::size()
00336 {
00337 return _NbValues;
00338 }
00339
00341 std::list<IObjectIA *> *CValueSet::getValues()
00342 {
00343
00344 std::list<IObjectIA *> *result = new std::list<IObjectIA *>;
00345 for (sint32 i = 0; i < _NbValues; i++ )
00346 {
00347 if ( _Values[i] )
00348 result->push_back( _Values[i] );
00349 }
00350 return result;
00351 }
00352
00353 const NLAIC::IBasicType *CValueSet::clone() const
00354 {
00355 NLAIC::IBasicType *tmp = new CValueSet( *this );
00356 return tmp;
00357 }
00358
00359 const NLAIC::IBasicType *CValueSet::newInstance() const
00360 {
00361 return clone();
00362 }
00363
00364 const NLAIC::CIdentType &CValueSet::getType() const
00365 {
00366 return IdValueSet;
00367 }
00368
00369 void CValueSet::save(NLMISC::IStream &os)
00370 {
00371 sint32 nb_Values = (sint32) _NbValues;
00372 os.serial( nb_Values );
00373 std::list<IObjectIA *> values;
00374 std::vector<sint32> pos;
00375
00376 for ( sint32 i = 0; i < _NbValues; i++ )
00377 {
00378 if ( _Values[i] )
00379 {
00380 values.push_back( _Values[i] );
00381 pos.push_back( i );
00382 }
00383 }
00384 sint32 size = (sint32) values.size();
00385 os.serial( size );
00386
00387 std::list<IObjectIA *>::iterator it_val = values.begin();
00388 std::vector<sint32>::iterator it_pos = pos.begin();
00389
00390 while ( it_val != values.end() )
00391 {
00392 os.serial( (NLAIC::CIdentType &) ( *it_val )->getType() );
00393 ( *it_val )->save( os );
00394 sint32 ip = (sint32) *it_pos;
00395 os.serial( ip );
00396 }
00397 }
00398
00399 void CValueSet::load(NLMISC::IStream &is)
00400 {
00401
00402 int i;
00403 for ( i = 0; i < _NbValues; i++ )
00404 if ( _Values[i] )
00405 _Values[i]->release();
00406 delete[] _Values;
00407
00408
00409 sint32 nb_Values;
00410 is.serial( nb_Values );
00411 _NbValues = (sint32) nb_Values;
00412 sint32 nbvals;
00413 is.serial( nbvals );
00414
00415 _Values = new IObjectIA *[ _NbValues ];
00416
00417 for ( i = 0; i < _NbValues; i++ )
00418 {
00419 _Values[ i ] = NULL;
00420 }
00421
00422 std::list<IObjectIA *> vals;
00423 std::vector<sint32> pos;
00424
00425 for ( i = 0; i < nbvals; i++ )
00426 {
00427 NLAIC::CIdentTypeAlloc id;
00428 is.serial( id );
00429 IObjectIA *tmp_val = (IObjectIA *) id.allocClass();
00430 tmp_val->load( is );
00431 tmp_val->incRef();
00432 vals.push_back( tmp_val );
00433 }
00434 }
00435
00436 void CValueSet::getDebugString(std::string &txt) const
00437 {
00438 std::string buf;
00439 txt += " <CValueSet> ";
00440 for (sint32 i = 0; i < _NbValues; i++ )
00441 {
00442 txt += " , ";
00443 if ( _Values[i] )
00444 {
00445 _Values[i]->getDebugString( buf );
00446
00447 txt += buf ;
00448 }
00449 else txt += "NULL";
00450 }
00451 }
00452
00453 IObjetOp *CValueSet::operator ! () const
00454 {
00455 CBoolType *result = new CBoolType ( !isTrue() );
00456 return result;
00457 }
00458
00459 IObjectIA *CValueSet::operator != (IObjectIA &a) const
00460 {
00461 if ( _NbValues != ((CValueSet &)a)._NbValues )
00462 {
00463 CBoolType *result = new CBoolType ( false );
00464 return result;
00465 }
00466
00467
00468 for (sint32 i = _NbValues; i < _NbValues; i++ )
00469 {
00470 if ( _Values[i] != ((CValueSet &)a)._Values[i] )
00471 {
00472 CBoolType *result = new CBoolType ( false );
00473 return result;
00474 }
00475
00476 }
00477 CBoolType *result = new CBoolType ( true );
00478 return result;
00479 }
00480
00481 IObjectIA *CValueSet::operator == (IObjectIA &a) const
00482 {
00483 if ( _NbValues != ((CValueSet &)a)._NbValues )
00484 {
00485 CBoolType *result = new CBoolType ( false );
00486 return result;
00487 }
00488
00489 for (sint32 i = 0; i < _NbValues; i++ )
00490 {
00491 bool test_result = (*_Values[i]) == *((CValueSet &)a)._Values[i];
00492
00493
00494
00495 if ( !test_result )
00496 {
00497 CBoolType *result = new CBoolType ( false );
00498 return result;
00499 }
00500 }
00501 CBoolType *result = new CBoolType ( true );
00502 return result;
00503 }
00504
00505 bool CValueSet::isEqual(const IBasicObjectIA &cmp) const
00506 {
00507 if ( _NbValues != ((CValueSet &)cmp)._NbValues )
00508 {
00509 return false;
00510 }
00511
00512 for (sint32 i = _NbValues; i < _NbValues; i++ )
00513 {
00514 if ( _Values[i] != ((CValueSet &)cmp)._Values[i] )
00515 {
00516 return false;
00517 }
00518 }
00519 return true;
00520 }
00521
00522 bool CValueSet::isTrue() const
00523 {
00524 return ( undefined() == (sint32) 0 );
00525 }
00526
00527 const IObjectIA::CProcessResult &CValueSet::run()
00528 {
00529 return IObjectIA::ProcessRun;
00530 }
00531
00532 CValueSet *CValueSet::forward(CClause *clause,std::vector<sint32> &pos)
00533 {
00534 CValueSet *result = new CValueSet( clause->nbVars() );
00535
00536 std::vector<sint32>::iterator it_pos = pos.begin();
00537
00538 for (sint32 i = 0; i < _NbValues; i++ )
00539 {
00540 if ( _Values[i] )
00541 {
00542 result->_Values[ *it_pos ] = _Values[i];
00543 _Values[i]->incRef();
00544 it_pos++;
00545 }
00546 }
00547 return result;
00548 }
00549
00550 void CValueSet::setSize(sint32 size)
00551 {
00552 _NbValues = size;
00553 sint32 i;
00554
00555 if ( _Values != NULL )
00556 {
00557 for ( i = 0; i < _NbValues; i++ );
00558 _Values[i]->release();
00559 delete _Values;
00560 }
00561
00562 _Values = new IObjectIA *[ _NbValues ];
00563
00564 for ( i = 0; i < _NbValues; i++ )
00565 {
00566 _Values[ i ] = NULL;
00567 }
00568 }
00569 }