public SearchFactoryImpl(SearchConfiguration cfg) 
{
		ReflectionManager reflectionManager = cfg.getReflectionManager();
		if ( reflectionManager == null ) {
			reflectionManager = new JavaReflectionManager();
		}
		this.indexingStrategy = defineIndexingStrategy( cfg ); //need to be done before the document builds
		initDocumentBuilders( cfg, reflectionManager );
		Set< Class< ? > > indexedClasses = documentBuilders.keySet();
		for (DocumentBuilder builder : documentBuilders.values()) {
			builder.postInitialize( indexedClasses );
		}
		//not really necessary today
		for (DocumentBuilder builder : containedInOnlyBuilders.values()) {
			builder.postInitialize( indexedClasses );
		}
		this.worker = WorkerFactory.createWorker( cfg, this );
		this.readerProvider = ReaderProviderFactory.createReaderProvider( cfg, this );
		this.filterCachingStrategy = buildFilterCachingStrategy( cfg.getProperties() );
		this.cacheBitResultsSize = ConfigurationParseHelper.getIntValue( cfg.getProperties(), Environment.CACHE_BIT_RESULT_SIZE, CachingWrapperFilter.DEFAULT_SIZE );
		this.barrier = 1; //write barrier
}

 public  void addClassToDirectoryProvider(Class clazz,
    DirectoryProvider directoryProvider) 
{
		//no need to set a read barrier, we only use this class in the init thread
		DirectoryProviderData data = dirProviderData.get(directoryProvider);
		if (data == null) {
			data = new DirectoryProviderData();
			dirProviderData.put( directoryProvider, data );
		}
		data.classes.add(clazz);
}

 public  void addDirectoryProvider(DirectoryProvider provider) 
{
		//no need to set a barrier we use this method in the init thread
		this.dirProviderData.put( provider, new DirectoryProviderData() );
}

 public  void addIndexingParameters(DirectoryProvider provider,
    LuceneIndexingParameters indexingParams) 
{
		//no need to set a read barrier, we run this method on the init thread
		dirProviderIndexingParams.put( provider, indexingParams );
}

 public  void addOptimizerStrategy(DirectoryProvider provider,
    OptimizerStrategy optimizerStrategy) 
{
		//no need to set a read barrier, we run this method on the init thread
		DirectoryProviderData data = dirProviderData.get(provider);
		if (data == null) {
			data = new DirectoryProviderData();
			dirProviderData.put( provider, data );
		}
		data.optimizerStrategy = optimizerStrategy;
}

 public  void close() 
{
		if (barrier != 0) { } //read barrier
		if ( stopped.compareAndSet( false, true) ) {
			try {
				worker.close();
			}
			catch (Exception e) {
				log.error( "Worker raises an exception on close()", e );
			}
			try {
				readerProvider.destroy();
			}
			catch (Exception e) {
				log.error( "ReaderProvider raises an exception on destroy()", e );
			}
			//TODO move to DirectoryProviderFactory for cleaner
			for (DirectoryProvider dp : getDirectoryProviders() ) {
				try {
					dp.stop();
				}
				catch (Exception e) {
					log.error( "DirectoryProvider raises an exception on stop() ", e );
				}
			}
		}
}

 public Analyzer getAnalyzer(String name) 
{
		if (barrier != 0) {} //read barrier
		final Analyzer analyzer = analyzers.get( name );
		if ( analyzer == null) throw new SearchException( "Unknown Analyzer definition: " + name);
		return analyzer;
}

 public Analyzer getAnalyzer(Class clazz) 
{
		if ( clazz ==  null) {
			throw new IllegalArgumentException( "A class has to be specified for retrieving a scoped analyzer" );
		}
		DocumentBuilder< ? > builder = documentBuilders.get( clazz );
		if ( builder == null ) {
			throw new IllegalArgumentException( "Entity for which to retrieve the scoped analyzer is not an @Indexed entity: " + clazz.getName() );
		}
		return builder.getAnalyzer();
}

 public BackendQueueProcessorFactory getBackendQueueProcessorFactory() 
{
	   
		if (barrier != 0) { } //read barrier
		return backendQueueProcessorFactory;
}

 public Set getClassesInDirectoryProvider(DirectoryProvider directoryProvider) 
{
		if (barrier != 0) { } //read barrier
		return Collections.unmodifiableSet( dirProviderData.get(directoryProvider).classes );
}

 public DocumentBuilder getContainedInOnlyBuilder(Class entityType) 
{
		if (barrier != 0) { } //read barrier
		return ( DocumentBuilder< T > ) containedInOnlyBuilders.get( entityType );
}

 public ReentrantLock getDirectoryProviderLock(DirectoryProvider dp) 
{
	
		if (barrier != 0) {} //read barrier
		return this.dirProviderData.get( dp ).dirLock;
}

 public Set getDirectoryProviders() 
{
		if (barrier != 0) { } //read barrier
		return this.dirProviderData.keySet();
}

 public DirectoryProvider[] getDirectoryProviders(Class entity) 
{
		if (barrier != 0) {} //read barrier
		DocumentBuilder< ? > documentBuilder = getDocumentBuilder( entity );
		return documentBuilder == null ? null : documentBuilder.getDirectoryProviders();
}

 public DocumentBuilder getDocumentBuilder(Class entityType) 
{
		if (barrier != 0) { } //read barrier
		return ( DocumentBuilder< T > ) documentBuilders.get( entityType );
}

 public Map getDocumentBuilders() 
{
		if (barrier != 0) { } //read barrier
		return documentBuilders;
}

 public int getFilterCacheBitResultsSize() 
{
		if (barrier != 0) {} //read barrier
		return cacheBitResultsSize;
}

 public FilterCachingStrategy getFilterCachingStrategy() 
{
		if (barrier != 0) {} //read barrier
		return filterCachingStrategy;
}

 public FilterDef getFilterDefinition(String name) 
{
		if (barrier != 0) {} //read barrier
		return filterDefinitions.get( name );
}

 public LuceneIndexingParameters getIndexingParameters(DirectoryProvider provider) 
{
		if (barrier != 0) {} //read barrier
		return dirProviderIndexingParams.get( provider );
}

 public String getIndexingStrategy() 
{
		if (barrier != 0) { } //read barrier
		return indexingStrategy;
}

 public OptimizerStrategy getOptimizerStrategy(DirectoryProvider provider) 
{
		if (barrier != 0) {} //read barrier
		return dirProviderData.get( provider ).optimizerStrategy;
}

 public ReaderProvider getReaderProvider() 
{
		if (barrier != 0) {} //read barrier
		return readerProvider;
}

 public Worker getWorker() 
{
		if (barrier != 0) { } //read barrier
		return worker;
}

 public  void optimize() 
{
		if (barrier != 0) {} //read barrier
		Set< Class< ? > > clazzs = getDocumentBuilders().keySet();
		for (Class clazz : clazzs) {
			optimize( clazz );
		}
}

 public  void optimize(Class entityType) 
{
		if (barrier != 0) {} //read barrier
		if ( ! getDocumentBuilders().containsKey( entityType ) ) {
			throw new SearchException("Entity not indexed: " + entityType);
		}
		List< LuceneWork > queue = new ArrayList< LuceneWork >(1);
		queue.add( new OptimizeLuceneWork( entityType ) );
		getBackendQueueProcessorFactory().getProcessor( queue ).run();
}

 public  void setBackendQueueProcessorFactory(BackendQueueProcessorFactory backendQueueProcessorFactory) 
{
		//no need to set a barrier, we init in the same thread as the init one
		this.backendQueueProcessorFactory = backendQueueProcessorFactory;
}