public DocumentBuilder(XClass clazz,
    Analyzer analyzer,
    DirectoryProvider directory,
    ReflectionManager reflectionManager) 
{
	      
		this.beanClass = clazz;
		this.analyzer = analyzer;
		this.directoryProvider = directory;
		//FIXME get rid of it when boost is stored?
		this.reflectionManager = reflectionManager;
		if ( clazz == null ) throw new AssertionFailure( "Unable to build a DocumemntBuilder with a null class" );
		rootPropertiesMetadata.boost = getBoost( clazz );
		Set< XClass > processedClasses = new HashSet< XClass >();
		processedClasses.add( clazz );
		initializeMembers(clazz, rootPropertiesMetadata, true, "", processedClasses );
		//processedClasses.remove( clazz ); for the sake of completness
		if ( idKeywordName == null ) {
			throw new SearchException( "No document id for: " + clazz.getName() );
		}
}

 public  void addWorkToQueue(T entity,
    Serializable id,
    WorkType workType,
    List queue,
    SearchFactory searchFactory) 
{
		Class entityClass = Hibernate.getClass( entity );
		//TODO with the caller loop we are in a n^2: optimize it using a HashMap for work recognition 
		for ( LuceneWork luceneWork : queue) {
			//whatever the actual work, we should ignore
			if ( luceneWork.getEntityClass() == entityClass
					&& luceneWork.getId().equals( id ) ) {//find a way to use Type.equals(x,y)
				return;
			}
		}
		boolean searchForContainers = false;
		if ( workType == WorkType.ADD ) {
			Document doc = getDocument( entity, id );
			queue.add( new AddLuceneWork( id, entityClass, doc ) );
			searchForContainers = true;
		}
		else if ( workType == WorkType.DELETE ) {
			queue.add( new DeleteLuceneWork(id, entityClass) );
		}
		else if ( workType == WorkType.UPDATE ) {
			Document doc = getDocument( entity, id );
			/**
			 * even with Lucene 2.1, use of indexWriter to update is not an option
			 * We can only delete by term, and the index doesn't have a term that
			 * uniquely identify the entry.
			 * But essentially the optimization we are doing is the same Lucene is doing, the only extra cost is the
			 * double file opening.
			 */
			queue.add( new DeleteLuceneWork(id, entityClass) );
			queue.add( new AddLuceneWork( id, entityClass, doc ) );
			searchForContainers = true;
		}
		else {
			throw new AssertionFailure("Unknown WorkType: " + workType);
		}
		/**
		 * When references are changed, either null or another one, we expect dirty checking to be triggered (both sides
		 * have to be updated)
		 * When the internal object is changed, we apply the {Add|Update}Work on containedIns
		 */
		if (searchForContainers) {
			processContainedIn(entity, queue, rootPropertiesMetadata, searchFactory);
		}
}

 public Analyzer getAnalyzer() 
{
		return analyzer;
}

 public DirectoryProvider getDirectoryProvider() 
{
		return directoryProvider;
}

 public Document getDocument(T instance,
    Serializable id) 
{
		Document doc = new Document();
		XClass instanceClass = reflectionManager.toXClass( instance.getClass() );
		if ( rootPropertiesMetadata.boost != null ) {
			doc.setBoost( rootPropertiesMetadata.boost );
		}
		{
			Field classField =
					new Field( CLASS_FIELDNAME, instanceClass.getName(), Field.Store.YES, Field.Index.UN_TOKENIZED );
			doc.add( classField );
			idBridge.set( idKeywordName, id, doc, Field.Store.YES, Field.Index.UN_TOKENIZED, idBoost );
		}
		buildDocumentFields( instance, doc, rootPropertiesMetadata );
		return doc;
}

 public static Class getDocumentClass(Document document) 
{
		String className = document.get( DocumentBuilder.CLASS_FIELDNAME );
		try {
			return ReflectHelper.classForName( className );
		}
		catch (ClassNotFoundException e) {
			throw new SearchException( "Unable to load indexed class: " + className, e );
		}
}

 public static Serializable getDocumentId(SearchFactory searchFactory,
    Class clazz,
    Document document) 
{
		DocumentBuilder builder = searchFactory.getDocumentBuilders().get( clazz );
		if ( builder == null ) throw new SearchException( "No Lucene configuration set up for: " + clazz.getName() );
		return (Serializable) builder.getIdBridge().get( builder.getIdKeywordName(), document );
}

 public TwoWayFieldBridge getIdBridge() 
{
		return idBridge;
}

 public String getIdKeywordName() 
{
		return idKeywordName;
}

 public Set getMappedSubclasses() 
{
		return mappedSubclasses;
}

 public Term getTerm(Serializable id) 
{
		return new Term( idKeywordName, idBridge.objectToString( id ) );
}

 public  void postInitialize(Set indexedClasses) 
{
		//this method does not requires synchronization
		Class plainClass = reflectionManager.toClass( beanClass );
		Set< Class > tempMappedSubclasses = new HashSet< Class >();
		//together with the caller this creates a o(2), but I think it's still faster than create the up hierarchy for each class
		for ( Class currentClass : indexedClasses ) {
			if ( plainClass.isAssignableFrom( currentClass ) ) tempMappedSubclasses.add( currentClass );
		}
		mappedSubclasses = Collections.unmodifiableSet( tempMappedSubclasses );
}