Skip to content

Commit

Permalink
HSEARCH-3589 Remove some duplicated code in the Lucene backend
Browse files Browse the repository at this point in the history
  • Loading branch information
yrodiere committed May 6, 2020
1 parent 10725be commit fa4a5d9
Show file tree
Hide file tree
Showing 11 changed files with 228 additions and 278 deletions.
@@ -0,0 +1,64 @@
/*
* 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 <http://www.gnu.org/licenses/lgpl-2.1.html>.
*/
package org.hibernate.search.backend.lucene.types.aggregation.impl;

import java.lang.invoke.MethodHandles;

import org.hibernate.search.backend.lucene.logging.impl.Log;
import org.hibernate.search.backend.lucene.types.codec.impl.LuceneFieldCodec;
import org.hibernate.search.engine.backend.types.converter.spi.DslConverter;
import org.hibernate.search.engine.backend.types.converter.spi.ProjectionConverter;
import org.hibernate.search.engine.reporting.spi.EventContexts;
import org.hibernate.search.util.common.logging.impl.LoggerFactory;

public abstract class AbstractLuceneFieldAggregationBuilderFactory<F>
implements LuceneFieldAggregationBuilderFactory {
protected static final Log log = LoggerFactory.make( Log.class, MethodHandles.lookup() );

protected final boolean aggregable;

protected final DslConverter<?, ? extends F> toFieldValueConverter;
protected final ProjectionConverter<? super F, ?> fromFieldValueConverter;

public AbstractLuceneFieldAggregationBuilderFactory(
boolean aggregable, DslConverter<?, ? extends F> toFieldValueConverter,
ProjectionConverter<? super F, ?> fromFieldValueConverter) {
this.aggregable = aggregable;
this.toFieldValueConverter = toFieldValueConverter;
this.fromFieldValueConverter = fromFieldValueConverter;
}

@Override
public boolean hasCompatibleCodec(LuceneFieldAggregationBuilderFactory other) {
if ( !getClass().equals( other.getClass() ) ) {
return false;
}
AbstractLuceneFieldAggregationBuilderFactory<?> castedOther =
(AbstractLuceneFieldAggregationBuilderFactory<?>) other;
return aggregable == castedOther.aggregable && getCodec().isCompatibleWith( castedOther.getCodec() );
}

@Override
public boolean hasCompatibleConverter(LuceneFieldAggregationBuilderFactory other) {
if ( !getClass().equals( other.getClass() ) ) {
return false;
}
AbstractLuceneFieldAggregationBuilderFactory<?> castedOther =
(AbstractLuceneFieldAggregationBuilderFactory<?>) other;
return toFieldValueConverter.isCompatibleWith( castedOther.toFieldValueConverter )
&& fromFieldValueConverter.isCompatibleWith( castedOther.fromFieldValueConverter );
}

protected abstract LuceneFieldCodec<F> getCodec();

protected void checkAggregable(String absoluteFieldPath) {
if ( !aggregable ) {
throw log.nonAggregableField( absoluteFieldPath,
EventContexts.fromIndexFieldAbsolutePath( absoluteFieldPath ) );
}
}
}
Expand Up @@ -6,70 +6,27 @@
*/
package org.hibernate.search.backend.lucene.types.aggregation.impl;

import java.lang.invoke.MethodHandles;

import org.hibernate.search.backend.lucene.logging.impl.Log;
import org.hibernate.search.backend.lucene.types.codec.impl.LuceneFieldCodec;
import org.hibernate.search.engine.backend.types.converter.spi.ProjectionConverter;
import org.hibernate.search.engine.backend.types.converter.spi.DslConverter;
import org.hibernate.search.engine.reporting.spi.EventContexts;
import org.hibernate.search.engine.search.common.ValueConvert;
import org.hibernate.search.util.common.logging.impl.LoggerFactory;

abstract class AbstractLuceneStandardFieldAggregationBuilderFactory<F>
implements LuceneFieldAggregationBuilderFactory {

private static final Log log = LoggerFactory.make( Log.class, MethodHandles.lookup() );
extends AbstractLuceneFieldAggregationBuilderFactory<F> {

private final boolean aggregable;

private final DslConverter<?, ? extends F> toFieldValueConverter;
private final DslConverter<? super F, ? extends F> rawToFieldValueConverter;
private final ProjectionConverter<? super F, ?> fromFieldValueConverter;
private final ProjectionConverter<? super F, F> rawFromFieldValueConverter;

AbstractLuceneStandardFieldAggregationBuilderFactory(boolean aggregable,
DslConverter<?, ? extends F> toFieldValueConverter,
DslConverter<? super F, ? extends F> rawToFieldValueConverter,
ProjectionConverter<? super F, ?> fromFieldValueConverter,
ProjectionConverter<? super F, F> rawFromFieldValueConverter) {
this.aggregable = aggregable;
this.toFieldValueConverter = toFieldValueConverter;
super( aggregable, toFieldValueConverter, fromFieldValueConverter );
this.rawToFieldValueConverter = rawToFieldValueConverter;
this.fromFieldValueConverter = fromFieldValueConverter;
this.rawFromFieldValueConverter = rawFromFieldValueConverter;
}

@Override
public boolean hasCompatibleCodec(LuceneFieldAggregationBuilderFactory other) {
if ( !getClass().equals( other.getClass() ) ) {
return false;
}
AbstractLuceneStandardFieldAggregationBuilderFactory<?> castedOther =
(AbstractLuceneStandardFieldAggregationBuilderFactory<?>) other;
return aggregable == castedOther.aggregable && getCodec().isCompatibleWith( castedOther.getCodec() );
}

@Override
public boolean hasCompatibleConverter(LuceneFieldAggregationBuilderFactory other) {
if ( !getClass().equals( other.getClass() ) ) {
return false;
}
AbstractLuceneStandardFieldAggregationBuilderFactory<?> castedOther =
(AbstractLuceneStandardFieldAggregationBuilderFactory<?>) other;
return toFieldValueConverter.isCompatibleWith( castedOther.toFieldValueConverter )
&& fromFieldValueConverter.isCompatibleWith( castedOther.fromFieldValueConverter );
}

protected abstract LuceneFieldCodec<F> getCodec();

protected void checkAggregable(String absoluteFieldPath) {
if ( !aggregable ) {
throw log.nonAggregableField( absoluteFieldPath,
EventContexts.fromIndexFieldAbsolutePath( absoluteFieldPath ) );
}
}

protected <T> DslConverter<?, ? extends F> getToFieldValueConverter(
String absoluteFieldPath, Class<T> expectedType, ValueConvert convert) {
DslConverter<?, ? extends F> result;
Expand Down
Expand Up @@ -21,23 +21,17 @@
import org.hibernate.search.util.common.logging.impl.LoggerFactory;

public class LuceneGeoPointFieldAggregationBuilderFactory
implements LuceneFieldAggregationBuilderFactory {
extends AbstractLuceneFieldAggregationBuilderFactory<GeoPoint> {

private static final Log log = LoggerFactory.make( Log.class, MethodHandles.lookup() );

private final boolean aggregable;

private final DslConverter<?, ? extends GeoPoint> toFieldValueConverter;
private final ProjectionConverter<? super GeoPoint, ?> fromFieldValueConverter;
private final LuceneFieldCodec<GeoPoint> codec;

public LuceneGeoPointFieldAggregationBuilderFactory(boolean aggregable,
DslConverter<?, ? extends GeoPoint> toFieldValueConverter,
ProjectionConverter<? super GeoPoint, ?> fromFieldValueConverter,
LuceneFieldCodec<GeoPoint> codec) {
this.aggregable = aggregable;
this.toFieldValueConverter = toFieldValueConverter;
this.fromFieldValueConverter = fromFieldValueConverter;
super( aggregable, toFieldValueConverter, fromFieldValueConverter );
this.codec = codec;
}

Expand All @@ -58,23 +52,7 @@ public <K> RangeAggregationBuilder<K> createRangeAggregationBuilder(LuceneSearch
}

@Override
public boolean hasCompatibleCodec(LuceneFieldAggregationBuilderFactory other) {
if ( !getClass().equals( other.getClass() ) ) {
return false;
}
LuceneGeoPointFieldAggregationBuilderFactory castedOther =
(LuceneGeoPointFieldAggregationBuilderFactory) other;
return aggregable == castedOther.aggregable && codec.isCompatibleWith( castedOther.codec );
}

@Override
public boolean hasCompatibleConverter(LuceneFieldAggregationBuilderFactory other) {
if ( !getClass().equals( other.getClass() ) ) {
return false;
}
LuceneGeoPointFieldAggregationBuilderFactory castedOther =
(LuceneGeoPointFieldAggregationBuilderFactory) other;
return toFieldValueConverter.isCompatibleWith( castedOther.toFieldValueConverter )
&& fromFieldValueConverter.isCompatibleWith( castedOther.fromFieldValueConverter );
protected LuceneFieldCodec<GeoPoint> getCodec() {
return codec;
}
}
Expand Up @@ -15,8 +15,7 @@
import org.hibernate.search.engine.search.common.ValueConvert;

public class LuceneNumericFieldAggregationBuilderFactory<F>
extends AbstractLuceneStandardFieldAggregationBuilderFactory<F>
implements LuceneFieldAggregationBuilderFactory {
extends AbstractLuceneStandardFieldAggregationBuilderFactory<F> {

private final AbstractLuceneNumericFieldCodec<F, ?> codec;

Expand Down
Expand Up @@ -53,7 +53,7 @@ public LuceneIndexFieldType<GeoPoint> toIndexFieldType() {
new LuceneGeoPointFieldPredicateBuilderFactory(
resolvedSearchable, dslConverter, codec
),
new LuceneGeoPointFieldSortBuilderFactory( resolvedSortable ),
new LuceneGeoPointFieldSortBuilderFactory( resolvedSortable, codec ),
new LuceneGeoPointFieldProjectionBuilderFactory(
resolvedProjectable, codec, projectionConverter, rawProjectionConverter
),
Expand Down
@@ -0,0 +1,93 @@
/*
* 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 <http://www.gnu.org/licenses/lgpl-2.1.html>.
*/
package org.hibernate.search.backend.lucene.types.projection.impl;

import java.lang.invoke.MethodHandles;
import java.util.Set;

import org.hibernate.search.backend.lucene.logging.impl.Log;
import org.hibernate.search.backend.lucene.search.projection.impl.LuceneFieldProjectionBuilder;
import org.hibernate.search.backend.lucene.types.codec.impl.LuceneFieldCodec;
import org.hibernate.search.engine.backend.types.converter.spi.ProjectionConverter;
import org.hibernate.search.engine.reporting.spi.EventContexts;
import org.hibernate.search.engine.search.common.ValueConvert;
import org.hibernate.search.engine.search.projection.spi.FieldProjectionBuilder;
import org.hibernate.search.util.common.logging.impl.LoggerFactory;

public abstract class AbstractLuceneFieldProjectionBuilderFactory<F> implements LuceneFieldProjectionBuilderFactory {
protected static final Log log = LoggerFactory.make( Log.class, MethodHandles.lookup() );

protected final boolean projectable;

protected final ProjectionConverter<? super F, ?> converter;
protected final ProjectionConverter<? super F, F> rawConverter;

protected final LuceneFieldCodec<F> codec;

public AbstractLuceneFieldProjectionBuilderFactory(
boolean projectable, ProjectionConverter<? super F, ?> converter,
ProjectionConverter<? super F, F> rawConverter, LuceneFieldCodec<F> codec) {
this.projectable = projectable;
this.converter = converter;
this.rawConverter = rawConverter;
this.codec = codec;
}

@Override
@SuppressWarnings("unchecked") // We check the cast is legal by asking the converter
public <T> FieldProjectionBuilder<T> createFieldValueProjectionBuilder(Set<String> indexNames, String absoluteFieldPath, String nestedDocumentPath,
Class<T> expectedType, ValueConvert convert) {
checkProjectable( absoluteFieldPath );

ProjectionConverter<? super F, ?> requestConverter = getConverter( convert );
if ( !requestConverter.isConvertedTypeAssignableTo( expectedType ) ) {
throw log.invalidProjectionInvalidType( absoluteFieldPath, expectedType,
EventContexts.fromIndexFieldAbsolutePath( absoluteFieldPath ) );
}

return (FieldProjectionBuilder<T>) new LuceneFieldProjectionBuilder<>(
indexNames, absoluteFieldPath, nestedDocumentPath, requestConverter, codec
);
}

@Override
public boolean hasCompatibleCodec(LuceneFieldProjectionBuilderFactory other) {
if ( !getClass().equals( other.getClass() ) ) {
return false;
}
AbstractLuceneFieldProjectionBuilderFactory<?> castedOther =
(AbstractLuceneFieldProjectionBuilderFactory<?>) other;
return projectable == castedOther.projectable && codec.isCompatibleWith( castedOther.codec );
}

@Override
public boolean hasCompatibleConverter(LuceneFieldProjectionBuilderFactory other) {
if ( !getClass().equals( other.getClass() ) ) {
return false;
}
AbstractLuceneFieldProjectionBuilderFactory<?> castedOther =
(AbstractLuceneFieldProjectionBuilderFactory<?>) other;
return converter.isCompatibleWith( castedOther.converter );
}

protected void checkProjectable(String absoluteFieldPath) {
if ( !projectable ) {
throw log.nonProjectableField( absoluteFieldPath,
EventContexts.fromIndexFieldAbsolutePath( absoluteFieldPath ) );
}
}

protected ProjectionConverter<? super F, ?> getConverter(ValueConvert convert) {
switch ( convert ) {
case NO:
return rawConverter;
case YES:
default:
return converter;
}
}
}

0 comments on commit fa4a5d9

Please sign in to comment.