org.hibernate.search.metadata.impl.IndexedTypeDescriptorImpl Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of infinispan-embedded-query
Infinispan Embedded Query All-in-One module
There is a newer version: 9.1.7.Final
/*
 * Hibernate Search, full-text search for your domain model
 *
 * License: GNU Lesser General Public License (LGPL), version 2.1 or later
 * See the lgpl.txt file in the root directory or .
 */
package org.hibernate.search.metadata.impl;

import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

import org.hibernate.search.engine.BoostStrategy;
import org.hibernate.search.engine.metadata.impl.DocumentFieldMetadata;
import org.hibernate.search.engine.metadata.impl.PropertyMetadata;
import org.hibernate.search.engine.metadata.impl.TypeMetadata;
import org.hibernate.search.indexes.spi.IndexManager;
import org.hibernate.search.metadata.FieldDescriptor;
import org.hibernate.search.metadata.IndexDescriptor;
import org.hibernate.search.metadata.IndexedTypeDescriptor;
import org.hibernate.search.metadata.PropertyDescriptor;
import org.hibernate.search.util.logging.impl.Log;
import org.hibernate.search.util.logging.impl.LoggerFactory;

/**
 * @author Hardy Ferentschik
 */
public class IndexedTypeDescriptorImpl implements IndexedTypeDescriptor {
	private static final Log log = LoggerFactory.make();

	private final Class indexedType;
	private final float classBoost;
	private final BoostStrategy boostStrategy;
	private final Map keyedPropertyDescriptors;
	private final Set propertyDescriptors;
	private final Set classBridgeFieldDescriptors;
	private final Set indexDescriptors;
	private final Map allFieldDescriptors;
	private final boolean sharded;

	public IndexedTypeDescriptorImpl(TypeMetadata typeMetadata, IndexManager[] indexManagers) {
		this.indexedType = typeMetadata.getType();
		this.classBoost = typeMetadata.getStaticBoost();
		this.boostStrategy = typeMetadata.getDynamicBoost();
		this.sharded = indexManagers.length > 1;

		// create the class bridge fields
		Set fieldDescriptorTmp = new HashSet();
		for ( DocumentFieldMetadata documentFieldMetadata : typeMetadata.getClassBridgeMetadata() ) {
			FieldDescriptor fieldDescriptor;
			if ( documentFieldMetadata.isNumeric() ) {
				fieldDescriptor = new NumericFieldDescriptorImpl( documentFieldMetadata );
			}
			else {
				fieldDescriptor = new FieldDescriptorImpl( documentFieldMetadata );
			}
			fieldDescriptorTmp.add( fieldDescriptor );
		}
		this.classBridgeFieldDescriptors = Collections.unmodifiableSet( fieldDescriptorTmp );

		// handle the property descriptor and their fields
		this.keyedPropertyDescriptors = Collections.unmodifiableMap( createPropertyDescriptors( typeMetadata ) );
		this.propertyDescriptors = Collections.unmodifiableSet(
				new HashSet(
						createPropertyDescriptors( typeMetadata ).values()
				)
		);
		this.allFieldDescriptors = Collections.unmodifiableMap( createAllFieldDescriptors() );

		// create the index descriptors
		Set indexDescriptorTmp = new HashSet();
		for ( IndexManager indexManager : indexManagers ) {
			indexDescriptorTmp.add( new IndexDescriptorImpl( indexManager ) );
		}
		this.indexDescriptors = Collections.unmodifiableSet( indexDescriptorTmp );

	}

	@Override
	public Class getType() {
		return indexedType;
	}

	@Override
	public boolean isIndexed() {
		return true;
	}

	@Override
	public boolean isSharded() {
		return sharded;
	}

	@Override
	public float getStaticBoost() {
		return classBoost;
	}

	@Override
	public BoostStrategy getDynamicBoost() {
		return boostStrategy;
	}

	@Override
	public Set getIndexDescriptors() {
		return indexDescriptors;
	}

	@Override
	public Set getIndexedProperties() {
		return propertyDescriptors;
	}

	@Override
	public PropertyDescriptor getProperty(String propertyName) {
		if ( propertyName == null ) {
			throw log.getPropertyNameCannotBeNullException();
		}
		for ( PropertyDescriptor propertyDescriptor : propertyDescriptors ) {
			if ( propertyDescriptor.getName().equals( propertyName ) ) {
				return propertyDescriptor;
			}
		}
		return null;
	}

	@Override
	public Set getIndexedFields() {
		return classBridgeFieldDescriptors;
	}

	@Override
	public FieldDescriptor getIndexedField(String fieldName) {
		if ( fieldName == null ) {
			throw log.getFieldNameCannotBeNullException();
		}
		return allFieldDescriptors.get( fieldName );
	}

	@Override
	public Set getFieldsForProperty(String propertyName) {
		if ( propertyName == null ) {
			throw log.getPropertyNameCannotBeNullException();
		}
		if ( keyedPropertyDescriptors.containsKey( propertyName ) ) {
			return keyedPropertyDescriptors.get( propertyName ).getIndexedFields();
		}
		else {
			return Collections.emptySet();
		}
	}

	@Override
	public String toString() {
		final StringBuilder sb = new StringBuilder( "IndexedTypeDescriptorImpl{" );
		sb.append( "indexedType=" ).append( indexedType );
		sb.append( ", classBoost=" ).append( classBoost );
		sb.append( ", boostStrategy=" ).append( boostStrategy );
		sb.append( ", keyedPropertyDescriptors=" ).append( keyedPropertyDescriptors );
		sb.append( ", propertyDescriptors=" ).append( propertyDescriptors );
		sb.append( ", classBridgeFieldDescriptors=" ).append( classBridgeFieldDescriptors );
		sb.append( ", indexDescriptors=" ).append( indexDescriptors );
		sb.append( ", allFieldDescriptors=" ).append( allFieldDescriptors );
		sb.append( ", sharded=" ).append( sharded );
		sb.append( '}' );
		return sb.toString();
	}

	private Map createPropertyDescriptors(TypeMetadata typeMetadata) {
		Map propertyDescriptorsTmp = new HashMap();
		for ( PropertyMetadata propertyMetadata : typeMetadata.getAllPropertyMetadata() ) {
			createOrMergeProperDescriptor( propertyDescriptorsTmp, propertyMetadata );
		}
		createOrMergeProperDescriptor( propertyDescriptorsTmp, typeMetadata.getIdPropertyMetadata() );
		return propertyDescriptorsTmp;
	}

	private void createOrMergeProperDescriptor(Map propertyDescriptorsTmp, PropertyMetadata propertyMetadata) {
		String propertyName = propertyMetadata.getPropertyAccessorName();
		Set tmpSet = new HashSet();
		if ( propertyDescriptorsTmp.containsKey( propertyName ) ) {
			tmpSet.addAll( propertyDescriptorsTmp.get( propertyName ).getIndexedFields() );
		}

		boolean id = false;
		for ( DocumentFieldMetadata documentFieldMetadata : propertyMetadata.getFieldMetadata() ) {
			if ( documentFieldMetadata.isId() ) {
				id = true;
			}
			FieldDescriptor fieldDescriptor;
			if ( documentFieldMetadata.isNumeric() ) {
				fieldDescriptor = new NumericFieldDescriptorImpl( documentFieldMetadata );
			}
			else {
				fieldDescriptor = new FieldDescriptorImpl( documentFieldMetadata );
			}
			tmpSet.add( fieldDescriptor );
		}
		PropertyDescriptor propertyDescriptor = new PropertyDescriptorImpl(
				propertyMetadata.getPropertyAccessorName(),
				id,
				tmpSet
		);

		propertyDescriptorsTmp.put( propertyDescriptor.getName(), propertyDescriptor );
	}

	private Map createAllFieldDescriptors() {
		Map fieldDescriptorMap = new HashMap();
		for ( FieldDescriptor fieldDescriptor : classBridgeFieldDescriptors ) {
			fieldDescriptorMap.put( fieldDescriptor.getName(), fieldDescriptor );
		}
		for ( PropertyDescriptor propertyDescriptor : propertyDescriptors ) {
			for ( FieldDescriptor fieldDescriptor : propertyDescriptor.getIndexedFields() ) {
				fieldDescriptorMap.put( fieldDescriptor.getName(), fieldDescriptor );
			}
		}
		return fieldDescriptorMap;
	}
}