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

AIDA_AnalysisFactory.cpp

Go to the documentation of this file.
00001 #include "AIDA_AnalysisFactory.h"
00002 #include "AIDA_Dev/IStoreFactory.h"
00003 #include "AIDA_Dev/IAnnotationFactory.h"
00004 #include "AIDA_Dev/IHistogramFactoryProvider.h"
00005 #include "AIDA_Dev/IDataPointSetFactoryProvider.h"
00006 #include "AIDA_Dev/ITupleFactoryProvider.h"
00007 #include "AIDA_Dev/ITreeFactoryProvider.h"
00008 #include "AIDA_Dev/IFitFactoryProvider.h"
00009 #include "AIDA_Dev/IFunctionFactoryProvider.h"
00010 #include "AIDA_Dev/IPlotterFactoryProvider.h"
00011 
00012 #include "AIDA_Dev/IDevTree.h"
00013 
00014 #include <stdexcept>
00015 
00016 
00017 AIDA::IAnalysisFactory* AIDA_createAnalysisFactory()
00018 {
00019   return new Anaphe::AIDA_AnalysisFactory_native::AIDA_AnalysisFactory;
00020 }
00021 
00022 std::string*
00023 Anaphe::AIDA_AnalysisFactory_native::AIDA_AnalysisFactory::m_storeFactoryTypes = 0;
00024 
00025 AIDA::Dev::IStoreFactory**
00026 Anaphe::AIDA_AnalysisFactory_native::AIDA_AnalysisFactory::m_storeFactories = 0;
00027 
00028 unsigned int
00029 Anaphe::AIDA_AnalysisFactory_native::AIDA_AnalysisFactory::m_numberOfStoreTypes = 0;
00030 
00031 AIDA::Dev::IAnnotationFactory*
00032 Anaphe::AIDA_AnalysisFactory_native::AIDA_AnalysisFactory::m_annotationFactory = 0;
00033 
00034 AIDA::Dev::IHistogramFactoryProvider*
00035 Anaphe::AIDA_AnalysisFactory_native::AIDA_AnalysisFactory::m_histogramFactoryProvider = 0;
00036 
00037 AIDA::Dev::IDataPointSetFactoryProvider*
00038 Anaphe::AIDA_AnalysisFactory_native::AIDA_AnalysisFactory::m_dataPointSetFactoryProvider = 0;
00039 
00040 AIDA::Dev::ITreeFactoryProvider*
00041 Anaphe::AIDA_AnalysisFactory_native::AIDA_AnalysisFactory::m_treeFactoryProvider = 0;
00042 
00043 AIDA::Dev::ITupleFactoryProvider*
00044 Anaphe::AIDA_AnalysisFactory_native::AIDA_AnalysisFactory::m_tupleFactoryProvider = 0;
00045 
00046 AIDA::Dev::IFunctionFactoryProvider*
00047 Anaphe::AIDA_AnalysisFactory_native::AIDA_AnalysisFactory::m_functionFactoryProvider = 0;
00048 
00049 AIDA::Dev::IFitFactoryProvider*
00050 Anaphe::AIDA_AnalysisFactory_native::AIDA_AnalysisFactory::m_fitFactoryProvider = 0;
00051 
00052 AIDA::Dev::IPlotterFactoryProvider*
00053 Anaphe::AIDA_AnalysisFactory_native::AIDA_AnalysisFactory::m_plotterFactoryProvider = 0;
00054 
00055 bool
00056 Anaphe::AIDA_AnalysisFactory_native::AIDA_AnalysisFactory::firstInstance = false;
00057 
00058 Anaphe::AIDA_AnalysisFactory_native::AIDA_AnalysisFactory::AIDA_AnalysisFactory()
00059 {
00060   if ( ! firstInstance ) {
00061     m_storeFactories = new AIDA::Dev::IStoreFactory*[100];
00062     m_storeFactoryTypes = new std::string[100];
00063     firstInstance = true;
00064   }
00065 }
00066 
00067 
00068 Anaphe::AIDA_AnalysisFactory_native::AIDA_AnalysisFactory::~AIDA_AnalysisFactory()
00069 {}
00070 
00071 
00072 bool
00073 Anaphe::AIDA_AnalysisFactory_native::AIDA_AnalysisFactory::registerStoreFactory( AIDA::Dev::IStoreFactory* factory,
00074                                                                                  const std::string& storeTypeC )
00075 {
00076   std::string storeType = storeTypeC;
00077   for ( unsigned int i = 0; i < storeType.size(); ++i ) storeType[i] = std::tolower( storeType[i] );
00078   bool bFound = false;
00079   unsigned int index = 0;
00080   for ( unsigned int i = 0; i < m_numberOfStoreTypes; ++i ) {
00081     if ( m_storeFactoryTypes[i] == storeType ) {
00082       bFound = true;
00083       index = i;
00084       break;
00085     }
00086   }
00087 
00088   if ( ! bFound ) {
00089     m_storeFactoryTypes[m_numberOfStoreTypes] = storeType;
00090     m_storeFactories[m_numberOfStoreTypes] = factory;
00091     m_numberOfStoreTypes++;
00092   }
00093   else {
00094     m_storeFactories[index] = factory;
00095   }
00096 
00097   return true;
00098 }
00099 
00100 
00101 AIDA::Dev::IStoreFactory*
00102 Anaphe::AIDA_AnalysisFactory_native::AIDA_AnalysisFactory::storeFactory( const std::string & storeTypeC )
00103 {
00104   std::string storeType = storeTypeC;
00105   for ( unsigned int i = 0; i < storeType.size(); ++i ) storeType[i] = std::tolower( storeType[i] );
00106   bool bFound = false;
00107   unsigned int index = 0;
00108   for ( unsigned int i = 0; i < m_numberOfStoreTypes; ++i ) {
00109     if ( m_storeFactoryTypes[i] == storeType ) {
00110       bFound = true;
00111       index = i;
00112       break;
00113     }
00114   }
00115 
00116   if ( ! bFound ) return 0;
00117   else return m_storeFactories[ index ];
00118 }
00119 
00120 
00121 bool
00122 Anaphe::AIDA_AnalysisFactory_native::AIDA_AnalysisFactory::registerAnnotationFactory( AIDA::Dev::IAnnotationFactory* factory )
00123 {
00124   m_annotationFactory = factory;
00125   return true;
00126 }
00127 
00128 
00129 AIDA::Dev::IAnnotationFactory*
00130 Anaphe::AIDA_AnalysisFactory_native::AIDA_AnalysisFactory::annotationFactory()
00131 {
00132   return m_annotationFactory;
00133 }
00134 
00135 
00136 bool
00137 Anaphe::AIDA_AnalysisFactory_native::AIDA_AnalysisFactory::registerHistogramFactoryProvider( AIDA::Dev::IHistogramFactoryProvider* provider )
00138 {
00139   m_histogramFactoryProvider = provider;
00140   return true;
00141 }
00142 
00143 
00144 AIDA::Dev::IHistogramFactoryProvider*
00145 Anaphe::AIDA_AnalysisFactory_native::AIDA_AnalysisFactory::histogramFactoryProvider()
00146 {
00147   return m_histogramFactoryProvider;
00148 }
00149 
00150 
00151 bool
00152 Anaphe::AIDA_AnalysisFactory_native::AIDA_AnalysisFactory::registerDataPointSetFactoryProvider( AIDA::Dev::IDataPointSetFactoryProvider* provider )
00153 {
00154   m_dataPointSetFactoryProvider = provider;
00155   return true;
00156 }
00157 
00158 
00159 AIDA::Dev::IDataPointSetFactoryProvider*
00160 Anaphe::AIDA_AnalysisFactory_native::AIDA_AnalysisFactory::dataPointSetFactoryProvider()
00161 {
00162   return m_dataPointSetFactoryProvider;
00163 }
00164 
00165 
00166 bool
00167 Anaphe::AIDA_AnalysisFactory_native::AIDA_AnalysisFactory::registerTreeFactoryProvider( AIDA::Dev::ITreeFactoryProvider* provider )
00168 {
00169   m_treeFactoryProvider = provider;
00170   return true;
00171 }
00172 
00173 
00174 AIDA::Dev::ITreeFactoryProvider*
00175 Anaphe::AIDA_AnalysisFactory_native::AIDA_AnalysisFactory::treeFactoryProvider()
00176 {
00177   return m_treeFactoryProvider;
00178 }
00179 
00180 
00181 bool
00182 Anaphe::AIDA_AnalysisFactory_native::AIDA_AnalysisFactory::registerTupleFactoryProvider( AIDA::Dev::ITupleFactoryProvider* provider )
00183 {
00184   m_tupleFactoryProvider = provider;
00185   return true;
00186 }
00187 
00188 
00189 AIDA::Dev::ITupleFactoryProvider*
00190 Anaphe::AIDA_AnalysisFactory_native::AIDA_AnalysisFactory::tupleFactoryProvider()
00191 {
00192   return m_tupleFactoryProvider;
00193 }
00194 
00195 
00196 bool
00197 Anaphe::AIDA_AnalysisFactory_native::AIDA_AnalysisFactory::registerFunctionFactoryProvider( AIDA::Dev::IFunctionFactoryProvider* provider )
00198 {
00199   m_functionFactoryProvider = provider;
00200   return true;
00201 }
00202 
00203 
00204 AIDA::Dev::IFunctionFactoryProvider*
00205 Anaphe::AIDA_AnalysisFactory_native::AIDA_AnalysisFactory::functionFactoryProvider()
00206 {
00207   return m_functionFactoryProvider;
00208 }
00209 
00210 
00211 bool
00212 Anaphe::AIDA_AnalysisFactory_native::AIDA_AnalysisFactory::registerFitFactoryProvider( AIDA::Dev::IFitFactoryProvider* provider )
00213 {
00214   m_fitFactoryProvider = provider;
00215   return true;
00216 }
00217 
00218 
00219 AIDA::Dev::IFitFactoryProvider*
00220 Anaphe::AIDA_AnalysisFactory_native::AIDA_AnalysisFactory::fitFactoryProvider()
00221 {
00222   return m_fitFactoryProvider;
00223 }
00224 
00225 
00226 bool
00227 Anaphe::AIDA_AnalysisFactory_native::AIDA_AnalysisFactory::registerPlotterFactoryProvider( AIDA::Dev::IPlotterFactoryProvider* provider )
00228 {
00229   m_plotterFactoryProvider = provider;
00230   return true;
00231 }
00232 
00233 
00234 AIDA::Dev::IPlotterFactoryProvider*
00235 Anaphe::AIDA_AnalysisFactory_native::AIDA_AnalysisFactory::plotterFactoryProvider()
00236 {
00237   return m_plotterFactoryProvider;
00238 }
00239 
00240 
00241 AIDA::ITreeFactory*
00242 Anaphe::AIDA_AnalysisFactory_native::AIDA_AnalysisFactory::createTreeFactory()
00243 {
00244   AIDA::Dev::ITreeFactoryProvider * p = treeFactoryProvider();
00245   if ( p ) return p->createFactory();
00246   else return 0;
00247 }
00248 
00249 
00250 AIDA::IHistogramFactory*
00251 Anaphe::AIDA_AnalysisFactory_native::AIDA_AnalysisFactory::createHistogramFactory( AIDA::ITree& tree )
00252 {
00253   AIDA::Dev::IHistogramFactoryProvider * p = histogramFactoryProvider();
00254   if ( p ) return p->createFactory( dynamic_cast<AIDA::Dev::IDevTree&>(tree) );
00255   else return 0;
00256 }
00257 
00258 
00259 AIDA::IDataPointSetFactory*
00260 Anaphe::AIDA_AnalysisFactory_native::AIDA_AnalysisFactory::createDataPointSetFactory( AIDA::ITree& tree )
00261 {
00262   AIDA::Dev::IDataPointSetFactoryProvider * p = dataPointSetFactoryProvider();
00263   if ( p ) return p->createFactory( dynamic_cast<AIDA::Dev::IDevTree&>(tree) );
00264   else return 0;
00265 }
00266 
00267 
00268 AIDA::ITupleFactory*
00269 Anaphe::AIDA_AnalysisFactory_native::AIDA_AnalysisFactory::createTupleFactory( AIDA::ITree& tree )
00270 {
00271   AIDA::Dev::ITupleFactoryProvider * p = tupleFactoryProvider();
00272   if ( p ) return p->createFactory( dynamic_cast<AIDA::Dev::IDevTree&>(tree) );
00273   else return 0;
00274 }
00275 
00276 
00277 AIDA::IFunctionFactory*
00278 Anaphe::AIDA_AnalysisFactory_native::AIDA_AnalysisFactory::createFunctionFactory( AIDA::ITree& tree )
00279 {
00280   AIDA::Dev::IFunctionFactoryProvider * p = functionFactoryProvider();
00281   if ( p ) return p->createFactory( dynamic_cast<AIDA::Dev::IDevTree&>(tree) );
00282   else return 0;
00283 }
00284 
00285 
00286 AIDA::IFitFactory*
00287 Anaphe::AIDA_AnalysisFactory_native::AIDA_AnalysisFactory::createFitFactory()
00288 {
00289   AIDA::Dev::IFitFactoryProvider * p = fitFactoryProvider();
00290   if ( p ) return p->createFactory();
00291   else return 0;
00292 }
00293 
00294 
00295 AIDA::IPlotterFactory*
00296 Anaphe::AIDA_AnalysisFactory_native::AIDA_AnalysisFactory::createPlotterFactory( int argc,
00297                                                                                  char** args )
00298 {
00299   AIDA::Dev::IPlotterFactoryProvider * p = plotterFactoryProvider();
00300   if ( p ) return p->createFactory( argc, args );
00301   else return 0;
00302 }

Generated on Tue Nov 19 12:32:03 2002 for AIDA_AnalysisFactory_native by doxygen1.2.16