00001 #include "AIDA_ChainedTuple.h"
00002 #include "AIDA_Dev/IBackingStore.h"
00003 #include "AIDA_Dev/ITupleVariableDescription.h"
00004 #include "AIDA_Dev/ITupleVariableStatistics.h"
00005 #include "AIDA/IAnnotation.h"
00006 #include "AIDA/IEvaluator.h"
00007 #include "AIDA/IFilter.h"
00008 #include "AIDA/IHistogram1D.h"
00009 #include "AIDA/IHistogram2D.h"
00010 #include "AIDA/IHistogram3D.h"
00011 #include "AIDA/ICloud1D.h"
00012 #include "AIDA/ICloud2D.h"
00013 #include "AIDA/ICloud3D.h"
00014 #include "AIDA/IProfile1D.h"
00015 #include "AIDA/IProfile2D.h"
00016 #include <stdexcept>
00017 #include <cmath>
00018
00019
00020 static const std::string nameKey = "Name";
00021
00022
00023 Anaphe::AIDA_Tuple_native::AIDA_ChainedTuple::AIDA_ChainedTuple( const std::vector<IDevTuple*>& tuples ):
00024 m_tuples( tuples ),
00025 m_header(),
00026 m_currentTuple( 0 )
00027 {
00028 if ( tuples.empty() || ! tuples.front() ) {
00029 throw std::runtime_error( "Not valid set of input tuples to create the chain" );
00030 }
00031 }
00032
00033
00034 Anaphe::AIDA_Tuple_native::AIDA_ChainedTuple::~AIDA_ChainedTuple()
00035 {}
00036
00037
00038 const std::string&
00039 Anaphe::AIDA_Tuple_native::AIDA_ChainedTuple::name() const
00040 {
00041 return m_header.annotation().value( nameKey );
00042 }
00043
00044
00045 bool
00046 Anaphe::AIDA_Tuple_native::AIDA_ChainedTuple::isUpToDate() const
00047 {
00048 return m_tuples.back()->isUpToDate();
00049 }
00050
00051
00052 void
00053 Anaphe::AIDA_Tuple_native::AIDA_ChainedTuple::setUpToDate( bool isUpToDate )
00054 {
00055 m_tuples.back()->setUpToDate( isUpToDate );
00056 }
00057
00058
00059 bool
00060 Anaphe::AIDA_Tuple_native::AIDA_ChainedTuple::setName( const std::string& newName )
00061 {
00062 AIDA::IAnnotation& annotation = m_header.annotation();
00063 annotation.setValue( nameKey, newName );
00064 return true;
00065 }
00066
00067
00068 const std::string&
00069 Anaphe::AIDA_Tuple_native::AIDA_ChainedTuple::userLevelClassType() const
00070 {
00071 return m_tuples.front()->userLevelClassType();
00072 }
00073
00074
00075 bool
00076 Anaphe::AIDA_Tuple_native::AIDA_ChainedTuple::connectToStore( AIDA::Dev::IBackingStore* store )
00077 {
00078 return true;
00079 }
00080
00081
00082 AIDA::Dev::IBackingStore*
00083 Anaphe::AIDA_Tuple_native::AIDA_ChainedTuple::store()
00084 {
00085 return m_tuples.back()->store();
00086 }
00087
00088
00089 const AIDA::Dev::IBackingStore*
00090 Anaphe::AIDA_Tuple_native::AIDA_ChainedTuple::store() const
00091 {
00092 return m_tuples.back()->store();
00093 }
00094
00095
00096 AIDA::Dev::ITupleHeader&
00097 Anaphe::AIDA_Tuple_native::AIDA_ChainedTuple::header()
00098 {
00099 return m_header;
00100 }
00101
00102
00103 const AIDA::Dev::ITupleHeader&
00104 Anaphe::AIDA_Tuple_native::AIDA_ChainedTuple::header() const
00105 {
00106 return m_header;
00107 }
00108
00109
00110 void*
00111 Anaphe::AIDA_Tuple_native::AIDA_ChainedTuple::variableAddress( const std::string& variableName )
00112 {
00113 return m_tuples[m_currentTuple]->variableAddress( variableName );
00114 }
00115
00116
00117 const void*
00118 Anaphe::AIDA_Tuple_native::AIDA_ChainedTuple::variableAddress( const std::string& variableName ) const
00119 {
00120 return m_tuples[m_currentTuple]->variableAddress( variableName );
00121 }
00122
00123
00124 const std::string&
00125 Anaphe::AIDA_Tuple_native::AIDA_ChainedTuple::title() const
00126 {
00127 return m_header.annotation().value( titleKey );
00128 }
00129
00130
00131 bool
00132 Anaphe::AIDA_Tuple_native::AIDA_ChainedTuple::setTitle(const std::string & title)
00133 {
00134 AIDA::IAnnotation& annotation = m_header.annotation();
00135 annotation.setValue( titleKey, title );
00136 return true;
00137 }
00138
00139
00140 AIDA::IAnnotation&
00141 Anaphe::AIDA_Tuple_native::AIDA_ChainedTuple::annotation()
00142 {
00143 return m_header.annotation();
00144 }
00145
00146
00147 const AIDA::IAnnotation&
00148 Anaphe::AIDA_Tuple_native::AIDA_ChainedTuple::annotation() const
00149 {
00150 return m_header.annotation();
00151 }
00152
00153
00154 bool
00155 Anaphe::AIDA_Tuple_native::AIDA_ChainedTuple::fill(int column, double value)
00156 {
00157 m_currentTuple = m_tuples.size() - 1;
00158 return m_tuples.back()->fill( column, value );
00159 }
00160
00161
00162 bool
00163 Anaphe::AIDA_Tuple_native::AIDA_ChainedTuple::fill(int column, float value)
00164 {
00165 m_currentTuple = m_tuples.size() - 1;
00166 return m_tuples.back()->fill( column, value );
00167 }
00168
00169
00170 bool
00171 Anaphe::AIDA_Tuple_native::AIDA_ChainedTuple::fill(int column, long value)
00172 {
00173 m_currentTuple = m_tuples.size() - 1;
00174 return m_tuples.back()->fill( column, value );
00175 }
00176
00177
00178 bool
00179 Anaphe::AIDA_Tuple_native::AIDA_ChainedTuple::fill(int column, int value)
00180 {
00181 m_currentTuple = m_tuples.size() - 1;
00182 return m_tuples.back()->fill( column, value );
00183 }
00184
00185
00186 bool
00187 Anaphe::AIDA_Tuple_native::AIDA_ChainedTuple::fill(int column, short value)
00188 {
00189 m_currentTuple = m_tuples.size() - 1;
00190 return m_tuples.back()->fill( column, value );
00191 }
00192
00193
00194 bool
00195 Anaphe::AIDA_Tuple_native::AIDA_ChainedTuple::fill(int column, char value)
00196 {
00197 m_currentTuple = m_tuples.size() - 1;
00198 return m_tuples.back()->fill( column, value );
00199 }
00200
00201
00202 bool
00203 Anaphe::AIDA_Tuple_native::AIDA_ChainedTuple::fill(int column, bool value)
00204 {
00205 m_currentTuple = m_tuples.size() - 1;
00206 return m_tuples.back()->fill( column, value );
00207 }
00208
00209
00210 bool
00211 Anaphe::AIDA_Tuple_native::AIDA_ChainedTuple::fill(int column, const std::string& value)
00212 {
00213 m_currentTuple = m_tuples.size() - 1;
00214 return m_tuples.back()->fill( column, value );
00215 }
00216
00217
00218 bool
00219 Anaphe::AIDA_Tuple_native::AIDA_ChainedTuple::fill(int column, const AIDA::ITupleEntry & value )
00220 {
00221 m_currentTuple = m_tuples.size() - 1;
00222 return m_tuples.back()->fill( column, value );
00223 }
00224
00225
00226 bool
00227 Anaphe::AIDA_Tuple_native::AIDA_ChainedTuple::fill(const std::vector<double>& values)
00228 {
00229 m_currentTuple = m_tuples.size() - 1;
00230 return m_tuples.back()->fill( values );
00231 }
00232
00233
00234 bool
00235 Anaphe::AIDA_Tuple_native::AIDA_ChainedTuple::fill(const std::vector<float>& values)
00236 {
00237 m_currentTuple = m_tuples.size() - 1;
00238 return m_tuples.back()->fill( values );
00239 }
00240
00241
00242 bool
00243 Anaphe::AIDA_Tuple_native::AIDA_ChainedTuple::addRow()
00244 {
00245 m_currentTuple = m_tuples.size() - 1;
00246 return m_tuples.back()->addRow();
00247 }
00248
00249
00250 void
00251 Anaphe::AIDA_Tuple_native::AIDA_ChainedTuple::resetRow()
00252 {
00253 m_tuples[m_currentTuple]->resetRow();
00254 }
00255
00256
00257 void
00258 Anaphe::AIDA_Tuple_native::AIDA_ChainedTuple::reset()
00259 {
00260 m_currentTuple = 0;
00261 for ( unsigned int i = 0; i < m_tuples.size(); ++i ) m_tuples[i]->reset();
00262 }
00263
00264
00265 int
00266 Anaphe::AIDA_Tuple_native::AIDA_ChainedTuple::rows() const
00267 {
00268 int nrows = 0;
00269 for ( unsigned int i = 0; i < m_tuples.size(); ++i ) nrows += m_tuples[i]->rows();
00270 return nrows;
00271 }
00272
00273 void
00274 Anaphe::AIDA_Tuple_native::AIDA_ChainedTuple::start()
00275 {
00276 m_currentTuple = 0;
00277 for ( unsigned int i = 0; i < m_tuples.size(); ++i ) m_tuples[i]->start();
00278 }
00279
00280
00281 bool
00282 Anaphe::AIDA_Tuple_native::AIDA_ChainedTuple::skip(int rows)
00283 {
00284 if ( rows < 0 ) return false;
00285 int currentRowNumber = m_tuples[m_currentTuple]->header().currentRowNumber();
00286 while ( static_cast<unsigned int>( m_currentTuple ) < m_tuples.size() ) {
00287 const int rowsInTuple = m_tuples[m_currentTuple]->rows();
00288 const int rowInTuple = currentRowNumber + rows;
00289 if ( rowInTuple < rowsInTuple - 1 ) {
00290 return m_tuples[m_currentTuple]->skip( rows );
00291 }
00292 else {
00293 rows -= rowsInTuple;
00294 m_currentTuple++;
00295 currentRowNumber = -1;
00296 }
00297 }
00298 return false;
00299 }
00300
00301
00302 bool
00303 Anaphe::AIDA_Tuple_native::AIDA_ChainedTuple::next()
00304 {
00305 while( m_currentTuple < m_tuples.size() ) {
00306 if ( m_tuples[m_currentTuple]->next() ) return true;
00307 ++m_currentTuple;
00308 }
00309 return false;
00310 }
00311
00312
00313 bool
00314 Anaphe::AIDA_Tuple_native::AIDA_ChainedTuple::setRow(int rowIndex)
00315 {
00316 while( rowIndex >= -1 && m_currentTuple < m_tuples.size() ) {
00317 if ( m_tuples[m_currentTuple]->setRow( rowIndex ) ) return true;
00318 rowIndex -= m_tuples[m_currentTuple]->rows();
00319 ++m_currentTuple;
00320 }
00321 return false;
00322 }
00323
00324
00325 int
00326 Anaphe::AIDA_Tuple_native::AIDA_ChainedTuple::findColumn(const std::string & name) const
00327 {
00328 return m_tuples[m_currentTuple]->findColumn( name );
00329 }
00330
00331
00332 double
00333 Anaphe::AIDA_Tuple_native::AIDA_ChainedTuple::getDouble(int column) const
00334 {
00335 return m_tuples[m_currentTuple]->getDouble( column );
00336 }
00337
00338
00339 float
00340 Anaphe::AIDA_Tuple_native::AIDA_ChainedTuple::getFloat(int column) const
00341 {
00342 return m_tuples[m_currentTuple]->getFloat( column );
00343 }
00344
00345
00346 int
00347 Anaphe::AIDA_Tuple_native::AIDA_ChainedTuple::getInt(int column) const
00348 {
00349 return m_tuples[m_currentTuple]->getInt( column );
00350 }
00351
00352
00353 short
00354 Anaphe::AIDA_Tuple_native::AIDA_ChainedTuple::getShort(int column) const
00355 {
00356 return m_tuples[m_currentTuple]->getShort( column );
00357 }
00358
00359
00360 long
00361 Anaphe::AIDA_Tuple_native::AIDA_ChainedTuple::getLong(int column) const
00362 {
00363 return m_tuples[m_currentTuple]->getLong( column );
00364 }
00365
00366
00367 char
00368 Anaphe::AIDA_Tuple_native::AIDA_ChainedTuple::getChar(int column) const
00369 {
00370 return m_tuples[m_currentTuple]->getChar( column );
00371 }
00372
00373
00374 bool
00375 Anaphe::AIDA_Tuple_native::AIDA_ChainedTuple::getBoolean(int column) const
00376 {
00377 return m_tuples[m_currentTuple]->getBoolean( column );
00378 }
00379
00380
00381 const std::string&
00382 Anaphe::AIDA_Tuple_native::AIDA_ChainedTuple::getString(int column) const
00383 {
00384 return m_tuples[m_currentTuple]->getString( column );
00385 }
00386
00387
00388 const AIDA::ITupleEntry*
00389 Anaphe::AIDA_Tuple_native::AIDA_ChainedTuple::getObject(int column) const
00390 {
00391 return m_tuples[m_currentTuple]->getObject( column );
00392 }
00393
00394
00395 const AIDA::ITuple*
00396 Anaphe::AIDA_Tuple_native::AIDA_ChainedTuple::getTuple(int column) const
00397 {
00398 return m_tuples[m_currentTuple]->getTuple( column );
00399 }
00400
00401
00402 AIDA::ITuple*
00403 Anaphe::AIDA_Tuple_native::AIDA_ChainedTuple::getTuple(int column)
00404 {
00405 return m_tuples[m_currentTuple]->getTuple( column );
00406 }
00407
00408
00409 int
00410 Anaphe::AIDA_Tuple_native::AIDA_ChainedTuple::columns() const
00411 {
00412 return m_tuples[m_currentTuple]->columns();
00413 }
00414
00415
00416 const std::string&
00417 Anaphe::AIDA_Tuple_native::AIDA_ChainedTuple::columnName(int column) const
00418 {
00419 return m_tuples[m_currentTuple]->columnName( column );
00420 }
00421
00422
00423 const std::string&
00424 Anaphe::AIDA_Tuple_native::AIDA_ChainedTuple::columnType(int column) const
00425 {
00426 return m_tuples[m_currentTuple]->columnType( column );
00427 }
00428
00429
00430 double
00431 Anaphe::AIDA_Tuple_native::AIDA_ChainedTuple::columnMin(int column) const
00432 {
00433 double mmin = m_tuples[0]->columnMin( column );
00434 for ( unsigned int i = 1; i < m_tuples.size(); ++i ) {
00435 const double tmin = m_tuples[i]->columnMin( column );
00436 if ( mmin > tmin ) mmin = tmin;
00437 }
00438 return mmin;
00439 }
00440
00441
00442 double
00443 Anaphe::AIDA_Tuple_native::AIDA_ChainedTuple::columnMax(int column) const
00444 {
00445 double mmax = m_tuples[0]->columnMax( column );
00446 for ( unsigned int i = 1; i < m_tuples.size(); ++i ) {
00447 const double tmax = m_tuples[i]->columnMax( column );
00448 if ( mmax < tmax ) mmax = tmax;
00449 }
00450 return mmax;
00451 }
00452
00453
00454 double
00455 Anaphe::AIDA_Tuple_native::AIDA_ChainedTuple::columnMean(int column) const
00456 {
00457 double mean = 0;
00458 int entries = 0;
00459 for ( unsigned int i = 0; i < m_tuples.size(); ++i ) {
00460 const double tmean = m_tuples[i]->columnMean( column );
00461 const int tentries = m_tuples[i]->rows();
00462 entries += tentries;
00463 mean += tmean * tentries;
00464 }
00465 if ( entries > 0 ) return ( mean / entries );
00466 else return 0;
00467 }
00468
00469
00470 double
00471 Anaphe::AIDA_Tuple_native::AIDA_ChainedTuple::columnRms(int column) const
00472 {
00473 double mean = 0;
00474 double rms = 0;
00475 int entries = 0;
00476 for ( unsigned int i = 0; i < m_tuples.size(); ++i ) {
00477 const double tmean = m_tuples[i]->columnMean( column );
00478 const int tentries = m_tuples[i]->rows();
00479 const double trms = m_tuples[i]->columnRms( column );
00480 entries += tentries;
00481 mean += tmean * tentries;
00482 rms += tentries * std::abs( tmean*tmean - trms*trms );
00483 }
00484 if ( entries > 0 ) {
00485 mean /= entries;
00486 rms /= entries;
00487 return std::sqrt( std::abs( rms - mean*mean ) );
00488 }
00489 else return 0;
00490 }
00491
00492
00493 bool
00494 Anaphe::AIDA_Tuple_native::AIDA_ChainedTuple::project( AIDA::IHistogram1D& histogram,
00495 AIDA::IEvaluator& evaluatorX )
00496 {
00497 for ( unsigned int i = 0; i < m_tuples.size(); ++i ) {
00498 if ( ! m_tuples[i]->project( histogram, evaluatorX ) ) return false;
00499 }
00500 return true;
00501 }
00502
00503
00504 bool
00505 Anaphe::AIDA_Tuple_native::AIDA_ChainedTuple::project( AIDA::IHistogram1D& histogram,
00506 AIDA::IEvaluator& evaluatorX,
00507 AIDA::IFilter& filter )
00508 {
00509 for ( unsigned int i = 0; i < m_tuples.size(); ++i ) {
00510 if ( ! m_tuples[i]->project( histogram, evaluatorX, filter ) ) return false;
00511 }
00512 return true;
00513 }
00514
00515
00516 bool
00517 Anaphe::AIDA_Tuple_native::AIDA_ChainedTuple::project( AIDA::IHistogram1D& histogram,
00518 AIDA::IEvaluator& evaluatorX,
00519 AIDA::IEvaluator& weight )
00520 {
00521 for ( unsigned int i = 0; i < m_tuples.size(); ++i ) {
00522 if ( ! m_tuples[i]->project( histogram, evaluatorX, weight ) ) return false;
00523 }
00524 return true;
00525 }
00526
00527
00528 bool
00529 Anaphe::AIDA_Tuple_native::AIDA_ChainedTuple::project( AIDA::IHistogram1D& histogram,
00530 AIDA::IEvaluator& evaluatorX,
00531 AIDA::IFilter& filter,
00532 AIDA::IEvaluator& weight )
00533 {
00534 for ( unsigned int i = 0; i < m_tuples.size(); ++i ) {
00535 if ( ! m_tuples[i]->project( histogram, evaluatorX, filter, weight ) ) return false;
00536 }
00537 return true;
00538 }
00539
00540
00541 bool
00542 Anaphe::AIDA_Tuple_native::AIDA_ChainedTuple::project( AIDA::IHistogram2D& histogram,
00543 AIDA::IEvaluator& evaluatorX,
00544 AIDA::IEvaluator& evaluatorY )
00545 {
00546 for ( unsigned int i = 0; i < m_tuples.size(); ++i ) {
00547 if ( ! m_tuples[i]->project( histogram, evaluatorX, evaluatorY ) ) return false;
00548 }
00549 return true;
00550 }
00551
00552
00553
00554 bool
00555 Anaphe::AIDA_Tuple_native::AIDA_ChainedTuple::project( AIDA::IHistogram2D& histogram,
00556 AIDA::IEvaluator& evaluatorX,
00557 AIDA::IEvaluator& evaluatorY,
00558 AIDA::IFilter& filter )
00559 {
00560 for ( unsigned int i = 0; i < m_tuples.size(); ++i ) {
00561 if ( ! m_tuples[i]->project( histogram, evaluatorX, evaluatorY, filter ) ) return false;
00562 }
00563 return true;
00564 }
00565
00566
00567 bool
00568 Anaphe::AIDA_Tuple_native::AIDA_ChainedTuple::project( AIDA::IHistogram2D& histogram,
00569 AIDA::IEvaluator& evaluatorX,
00570 AIDA::IEvaluator& evaluatorY,
00571 AIDA::IEvaluator& weight )
00572 {
00573 for ( unsigned int i = 0; i < m_tuples.size(); ++i ) {
00574 if ( ! m_tuples[i]->project( histogram, evaluatorX, evaluatorY, weight ) ) return false;
00575 }
00576 return true;
00577 }
00578
00579
00580 bool
00581 Anaphe::AIDA_Tuple_native::AIDA_ChainedTuple::project( AIDA::IHistogram2D& histogram,
00582 AIDA::IEvaluator& evaluatorX,
00583 AIDA::IEvaluator& evaluatorY,
00584 AIDA::IFilter& filter,
00585 AIDA::IEvaluator& weight )
00586 {
00587 for ( unsigned int i = 0; i < m_tuples.size(); ++i ) {
00588 if ( ! m_tuples[i]->project( histogram, evaluatorX, evaluatorY, filter, weight ) ) return false;
00589 }
00590 return true;
00591 }
00592
00593
00594 bool
00595 Anaphe::AIDA_Tuple_native::AIDA_ChainedTuple::project( AIDA::IHistogram3D& histogram,
00596 AIDA::IEvaluator& evaluatorX,
00597 AIDA::IEvaluator& evaluatorY,
00598 AIDA::IEvaluator& evaluatorZ )
00599 {
00600 for ( unsigned int i = 0; i < m_tuples.size(); ++i ) {
00601 if ( ! m_tuples[i]->project( histogram, evaluatorX, evaluatorY, evaluatorZ ) ) return false;
00602 }
00603 return true;
00604 }
00605
00606
00607 bool
00608 Anaphe::AIDA_Tuple_native::AIDA_ChainedTuple::project( AIDA::IHistogram3D& histogram,
00609 AIDA::IEvaluator& evaluatorX,
00610 AIDA::IEvaluator& evaluatorY,
00611 AIDA::IEvaluator& evaluatorZ,
00612 AIDA::IFilter& filter )
00613 {
00614 for ( unsigned int i = 0; i < m_tuples.size(); ++i ) {
00615 if ( ! m_tuples[i]->project( histogram, evaluatorX, evaluatorY, evaluatorZ, filter ) ) return false;
00616 }
00617 return true;
00618 }
00619
00620
00621 bool
00622 Anaphe::AIDA_Tuple_native::AIDA_ChainedTuple::project( AIDA::IHistogram3D& histogram,
00623 AIDA::IEvaluator& evaluatorX,
00624 AIDA::IEvaluator& evaluatorY,
00625 AIDA::IEvaluator& evaluatorZ,
00626 AIDA::IEvaluator& weight )
00627 {
00628 for ( unsigned int i = 0; i < m_tuples.size(); ++i ) {
00629 if ( ! m_tuples[i]->project( histogram, evaluatorX, evaluatorY, evaluatorZ, weight ) ) return false;
00630 }
00631 return true;
00632 }
00633
00634
00635 bool
00636 Anaphe::AIDA_Tuple_native::AIDA_ChainedTuple::project( AIDA::IHistogram3D& histogram,
00637 AIDA::IEvaluator& evaluatorX,
00638 AIDA::IEvaluator& evaluatorY,
00639 AIDA::IEvaluator& evaluatorZ,
00640 AIDA::IFilter& filter,
00641 AIDA::IEvaluator& weight )
00642 {
00643 for ( unsigned int i = 0; i < m_tuples.size(); ++i ) {
00644 if ( ! m_tuples[i]->project( histogram, evaluatorX, evaluatorY, evaluatorZ, filter, weight ) ) return false;
00645 }
00646 return true;
00647 }
00648
00649
00650 bool
00651 Anaphe::AIDA_Tuple_native::AIDA_ChainedTuple::project( AIDA::ICloud1D& cloud,
00652 AIDA::IEvaluator& evaluatorX )
00653 {
00654 for ( unsigned int i = 0; i < m_tuples.size(); ++i ) {
00655 if ( ! m_tuples[i]->project( cloud, evaluatorX ) ) return false;
00656 }
00657 return true;
00658 }
00659
00660
00661 bool
00662 Anaphe::AIDA_Tuple_native::AIDA_ChainedTuple::project( AIDA::ICloud1D& cloud,
00663 AIDA::IEvaluator& evaluatorX,
00664 AIDA::IFilter& filter )
00665 {
00666 for ( unsigned int i = 0; i < m_tuples.size(); ++i ) {
00667 if ( ! m_tuples[i]->project( cloud, evaluatorX, filter ) ) return false;
00668 }
00669 return true;
00670 }
00671
00672
00673 bool
00674 Anaphe::AIDA_Tuple_native::AIDA_ChainedTuple::project( AIDA::ICloud1D& cloud,
00675 AIDA::IEvaluator& evaluatorX,
00676 AIDA::IEvaluator& weight )
00677 {
00678 for ( unsigned int i = 0; i < m_tuples.size(); ++i ) {
00679 if ( ! m_tuples[i]->project( cloud, evaluatorX, weight ) ) return false;
00680 }
00681 return true;
00682 }
00683
00684
00685 bool
00686 Anaphe::AIDA_Tuple_native::AIDA_ChainedTuple::project( AIDA::ICloud1D& cloud,
00687 AIDA::IEvaluator& evaluatorX,
00688 AIDA::IFilter& filter,
00689 AIDA::IEvaluator& weight )
00690 {
00691 for ( unsigned int i = 0; i < m_tuples.size(); ++i ) {
00692 if ( ! m_tuples[i]->project( cloud, evaluatorX, filter, weight ) ) return false;
00693 }
00694 return true;
00695 }
00696
00697
00698 bool
00699 Anaphe::AIDA_Tuple_native::AIDA_ChainedTuple::project( AIDA::ICloud2D& cloud,
00700 AIDA::IEvaluator& evaluatorX,
00701 AIDA::IEvaluator& evaluatorY )
00702 {
00703 for ( unsigned int i = 0; i < m_tuples.size(); ++i ) {
00704 if ( ! m_tuples[i]->project( cloud, evaluatorX, evaluatorY ) ) return false;
00705 }
00706 return true;
00707 }
00708
00709
00710
00711 bool
00712 Anaphe::AIDA_Tuple_native::AIDA_ChainedTuple::project( AIDA::ICloud2D& cloud,
00713 AIDA::IEvaluator& evaluatorX,
00714 AIDA::IEvaluator& evaluatorY,
00715 AIDA::IFilter& filter )
00716 {
00717 for ( unsigned int i = 0; i < m_tuples.size(); ++i ) {
00718 if ( ! m_tuples[i]->project( cloud, evaluatorX, evaluatorY, filter ) ) return false;
00719 }
00720 return true;
00721 }
00722
00723
00724 bool
00725 Anaphe::AIDA_Tuple_native::AIDA_ChainedTuple::project( AIDA::ICloud2D& cloud,
00726 AIDA::IEvaluator& evaluatorX,
00727 AIDA::IEvaluator& evaluatorY,
00728 AIDA::IEvaluator& weight )
00729 {
00730 for ( unsigned int i = 0; i < m_tuples.size(); ++i ) {
00731 if ( ! m_tuples[i]->project( cloud, evaluatorX, evaluatorY, weight ) ) return false;
00732 }
00733 return true;
00734 }
00735
00736
00737 bool
00738 Anaphe::AIDA_Tuple_native::AIDA_ChainedTuple::project( AIDA::ICloud2D& cloud,
00739 AIDA::IEvaluator& evaluatorX,
00740 AIDA::IEvaluator& evaluatorY,
00741 AIDA::IFilter& filter,
00742 AIDA::IEvaluator& weight )
00743 {
00744 for ( unsigned int i = 0; i < m_tuples.size(); ++i ) {
00745 if ( ! m_tuples[i]->project( cloud, evaluatorX, evaluatorY, filter, weight ) ) return false;
00746 }
00747 return true;
00748 }
00749
00750
00751 bool
00752 Anaphe::AIDA_Tuple_native::AIDA_ChainedTuple::project( AIDA::ICloud3D& cloud,
00753 AIDA::IEvaluator& evaluatorX,
00754 AIDA::IEvaluator& evaluatorY,
00755 AIDA::IEvaluator& evaluatorZ )
00756 {
00757 for ( unsigned int i = 0; i < m_tuples.size(); ++i ) {
00758 if ( ! m_tuples[i]->project( cloud, evaluatorX, evaluatorY, evaluatorZ ) ) return false;
00759 }
00760 return true;
00761 }
00762
00763
00764 bool
00765 Anaphe::AIDA_Tuple_native::AIDA_ChainedTuple::project( AIDA::ICloud3D& cloud,
00766 AIDA::IEvaluator& evaluatorX,
00767 AIDA::IEvaluator& evaluatorY,
00768 AIDA::IEvaluator& evaluatorZ,
00769 AIDA::IFilter& filter )
00770 {
00771 for ( unsigned int i = 0; i < m_tuples.size(); ++i ) {
00772 if ( ! m_tuples[i]->project( cloud, evaluatorX, evaluatorY, evaluatorZ, filter ) ) return false;
00773 }
00774 return true;
00775 }
00776
00777
00778 bool
00779 Anaphe::AIDA_Tuple_native::AIDA_ChainedTuple::project( AIDA::ICloud3D& cloud,
00780 AIDA::IEvaluator& evaluatorX,
00781 AIDA::IEvaluator& evaluatorY,
00782 AIDA::IEvaluator& evaluatorZ,
00783 AIDA::IEvaluator& weight )
00784 {
00785 for ( unsigned int i = 0; i < m_tuples.size(); ++i ) {
00786 if ( ! m_tuples[i]->project( cloud, evaluatorX, evaluatorY, evaluatorZ, weight ) ) return false;
00787 }
00788 return true;
00789 }
00790
00791
00792 bool
00793 Anaphe::AIDA_Tuple_native::AIDA_ChainedTuple::project( AIDA::ICloud3D& cloud,
00794 AIDA::IEvaluator& evaluatorX,
00795 AIDA::IEvaluator& evaluatorY,
00796 AIDA::IEvaluator& evaluatorZ,
00797 AIDA::IFilter& filter,
00798 AIDA::IEvaluator& weight )
00799 {
00800 for ( unsigned int i = 0; i < m_tuples.size(); ++i ) {
00801 if ( ! m_tuples[i]->project( cloud, evaluatorX, evaluatorY, evaluatorZ, filter, weight ) ) return false;
00802 }
00803 return true;
00804 }
00805
00806
00807 bool
00808 Anaphe::AIDA_Tuple_native::AIDA_ChainedTuple::project( AIDA::IProfile1D& profile,
00809 AIDA::IEvaluator& evaluatorX,
00810 AIDA::IEvaluator& evaluatorY )
00811 {
00812 for ( unsigned int i = 0; i < m_tuples.size(); ++i ) {
00813 if ( ! m_tuples[i]->project( profile, evaluatorX, evaluatorY ) ) return false;
00814 }
00815 return true;
00816 }
00817
00818
00819
00820 bool
00821 Anaphe::AIDA_Tuple_native::AIDA_ChainedTuple::project( AIDA::IProfile1D& profile,
00822 AIDA::IEvaluator& evaluatorX,
00823 AIDA::IEvaluator& evaluatorY,
00824 AIDA::IFilter& filter )
00825 {
00826 for ( unsigned int i = 0; i < m_tuples.size(); ++i ) {
00827 if ( ! m_tuples[i]->project( profile, evaluatorX, evaluatorY, filter ) ) return false;
00828 }
00829 return true;
00830 }
00831
00832
00833 bool
00834 Anaphe::AIDA_Tuple_native::AIDA_ChainedTuple::project( AIDA::IProfile1D& profile,
00835 AIDA::IEvaluator& evaluatorX,
00836 AIDA::IEvaluator& evaluatorY,
00837 AIDA::IEvaluator& weight )
00838 {
00839 for ( unsigned int i = 0; i < m_tuples.size(); ++i ) {
00840 if ( ! m_tuples[i]->project( profile, evaluatorX, evaluatorY, weight ) ) return false;
00841 }
00842 return true;
00843 }
00844
00845
00846 bool
00847 Anaphe::AIDA_Tuple_native::AIDA_ChainedTuple::project( AIDA::IProfile1D& profile,
00848 AIDA::IEvaluator& evaluatorX,
00849 AIDA::IEvaluator& evaluatorY,
00850 AIDA::IFilter& filter,
00851 AIDA::IEvaluator& weight )
00852 {
00853 for ( unsigned int i = 0; i < m_tuples.size(); ++i ) {
00854 if ( ! m_tuples[i]->project( profile, evaluatorX, evaluatorY, filter, weight ) ) return false;
00855 }
00856 return true;
00857 }
00858
00859
00860 bool
00861 Anaphe::AIDA_Tuple_native::AIDA_ChainedTuple::project( AIDA::IProfile2D& profile,
00862 AIDA::IEvaluator& evaluatorX,
00863 AIDA::IEvaluator& evaluatorY,
00864 AIDA::IEvaluator& evaluatorZ )
00865 {
00866 for ( unsigned int i = 0; i < m_tuples.size(); ++i ) {
00867 if ( ! m_tuples[i]->project( profile, evaluatorX, evaluatorY, evaluatorZ ) ) return false;
00868 }
00869 return true;
00870 }
00871
00872
00873 bool
00874 Anaphe::AIDA_Tuple_native::AIDA_ChainedTuple::project( AIDA::IProfile2D& profile,
00875 AIDA::IEvaluator& evaluatorX,
00876 AIDA::IEvaluator& evaluatorY,
00877 AIDA::IEvaluator& evaluatorZ,
00878 AIDA::IFilter& filter )
00879 {
00880 for ( unsigned int i = 0; i < m_tuples.size(); ++i ) {
00881 if ( ! m_tuples[i]->project( profile, evaluatorX, evaluatorY, evaluatorZ, filter ) ) return false;
00882 }
00883 return true;
00884 }
00885
00886
00887 bool
00888 Anaphe::AIDA_Tuple_native::AIDA_ChainedTuple::project( AIDA::IProfile2D& profile,
00889 AIDA::IEvaluator& evaluatorX,
00890 AIDA::IEvaluator& evaluatorY,
00891 AIDA::IEvaluator& evaluatorZ,
00892 AIDA::IEvaluator& weight )
00893 {
00894 for ( unsigned int i = 0; i < m_tuples.size(); ++i ) {
00895 if ( ! m_tuples[i]->project( profile, evaluatorX, evaluatorY, evaluatorZ, weight ) ) return false;
00896 }
00897 return true;
00898 }
00899
00900
00901 bool
00902 Anaphe::AIDA_Tuple_native::AIDA_ChainedTuple::project( AIDA::IProfile2D& profile,
00903 AIDA::IEvaluator& evaluatorX,
00904 AIDA::IEvaluator& evaluatorY,
00905 AIDA::IEvaluator& evaluatorZ,
00906 AIDA::IFilter& filter,
00907 AIDA::IEvaluator& weight )
00908 {
00909 for ( unsigned int i = 0; i < m_tuples.size(); ++i ) {
00910 if ( ! m_tuples[i]->project( profile, evaluatorX, evaluatorY, evaluatorZ, filter, weight ) ) return false;
00911 }
00912 return true;
00913 }