Main Page   Namespace List   Class Hierarchy   Alphabetical List   Compound List   File List   Compound Members   File Members  

AIDA_ChainedTuple.cpp

Go to the documentation of this file.
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 // static const std::string titleKey = "Title"; // defined in aida
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 }

Generated on Tue Feb 18 17:51:19 2003 for AIDA_Tuple_native by doxygen1.2.16