Java IndexType类代码示例

import com.threewks.gaetools.search.gae.meta.IndexType; //导入依赖的package包/类
protected SortOptions.Builder buildSortOptions(List<OrderComponent> order) {
    SortOptions.Builder sortOptions = SortOptions.newBuilder();
    for (OrderComponent sort : order) {
        String fieldName = getEncodedFieldName(sort.getField());
        SortExpression.Builder expression = SortExpression.newBuilder().setExpression(fieldName);
        expression = expression.setDirection(sort.isAscending() ? SortExpression.SortDirection.ASCENDING : SortExpression.SortDirection.DESCENDING);
        IndexType indexType = metadata.getIndexType(sort.getField());
        if (IndexType.SmallDecimal == indexType || IndexType.BigDecimal == indexType) {
            expression = expression.setDefaultValueNumeric(sort.isDescending() ? IntLow : IntHigh);
        } else if (IndexType.Date == indexType) {
            expression = expression.setDefaultValueDate(sort.isDescending() ? DateLow : DateHigh);
        } else {
            expression = expression.setDefaultValue(sort.isDescending() ? StringLow : StringHigh);
        }
        sortOptions = sortOptions.addSortExpression(expression);
    }
    return sortOptions;
}
 

import com.threewks.gaetools.search.gae.meta.IndexType; //导入依赖的package包/类
@Test
public void shouldConvertObjectToEnum() {
    ObjectToEnum<Object, IndexType> transformer = new ObjectToEnum<>(IndexType.class);

    assertThat(transformer.from(null), is(nullValue()));
    assertThat(transformer.from(""), is(nullValue()));
    assertThat(transformer.from("junk"), is(nullValue()));
    assertThat(transformer.from(1), is(nullValue()));

    assertThat(transformer.from("Automatic"), is(IndexType.Automatic));
    assertThat(transformer.from("automatic"), is(IndexType.Automatic));
    assertThat(transformer.from("AUTOMATIC"), is(IndexType.Automatic));
    assertThat(transformer.from("  AutoMATIC  "), is(IndexType.Automatic));

    assertThat(transformer.from("BigDecimal"), is(IndexType.BigDecimal));
    assertThat(transformer.from("bigdecimal"), is(IndexType.BigDecimal));
    assertThat(transformer.from("BIGDECIMAL"), is(IndexType.BigDecimal));
    assertThat(transformer.from("  BigdeCImal  "), is(IndexType.BigDecimal));

    assertThat(transformer.from(IndexType.BigDecimal), is(IndexType.BigDecimal));
}
 

import com.threewks.gaetools.search.gae.meta.IndexType; //导入依赖的package包/类
<F> Field buildField(SearchMetadata<T, K> metadata, String field, Object value) {
    com.google.appengine.api.search.Field.Builder fieldBuilder = Field.newBuilder().setName(metadata.getEncodedFieldName(field));
    IndexType indexType = metadata.getIndexType(field);
    FieldMediator<F> fieldMediator = fieldMediators.get(indexType);
    F normalised = fieldMediator.normalise(transformerManager, value);
    fieldMediator.setValue(fieldBuilder, normalised);
    return fieldBuilder.build();
}
 

import com.threewks.gaetools.search.gae.meta.IndexType; //导入依赖的package包/类
protected List<String> convertValuesToString(String field, Collection<Object> values) {
    IndexType indexType = metadata.getIndexType(field);
    FieldMediator<?> indexTypeFieldBuilder = fieldMediators.get(indexType);
    List<String> stringValues = new ArrayList<>();
    for (Object value : values) {
        stringValues.add(convertSingleValueToString(field, value, metadata, indexTypeFieldBuilder));
    }
    return stringValues;
}
 

import com.threewks.gaetools.search.gae.meta.IndexType; //导入依赖的package包/类
@SuppressWarnings("unchecked")
public <T> FieldMediator<T> get(IndexType indexType) {
    FieldMediator<T> result = (FieldMediator<T>) fieldMediators.get(indexType);
    if (result == null) {
        throw new SearchException("No %s present for %s '%s'", FieldMediator.class.getSimpleName(), IndexType.class.getSimpleName(), indexType);
    }
    return result;
}
 

import com.threewks.gaetools.search.gae.meta.IndexType; //导入依赖的package包/类
protected static Map<IndexType, FieldMediator<?>> initIndexFieldBuilders() {
    Map<IndexType, FieldMediator<?>> map = new HashMap<>();
    map.put(IndexType.Automatic, new TextFieldMediator());
    map.put(IndexType.BigDecimal, new BigDecimalFieldMediator());
    map.put(IndexType.Date, new DateFieldMediator());
    map.put(IndexType.GeoPoint, new GeoPointFieldMediator());
    map.put(IndexType.Html, new HtmlFieldMediator());
    map.put(IndexType.Identifier, new AtomFieldMediator());
    map.put(IndexType.SmallDecimal, new SmallDecimalFieldMediator());
    map.put(IndexType.Text, new TextFieldMediator());
    return map;
}
 

import com.threewks.gaetools.search.gae.meta.IndexType; //导入依赖的package包/类
public static IndexTypeLookup defaultIndexTypeLookup() {
    IndexTypeLookup indexTypeLookup = new IndexTypeLookup();
    indexTypeLookup.addMapping(Key.class, IndexType.Identifier);
    indexTypeLookup.addMapping(com.google.appengine.api.datastore.Key.class, IndexType.Identifier);
    indexTypeLookup.addMapping(GeoPt.class, IndexType.GeoPoint);
    return indexTypeLookup;
}
 

import com.threewks.gaetools.search.gae.meta.IndexType; //导入依赖的package包/类
@Test
public void shouldNormaliseDifferentTypes() {
    assertThat(atomFieldMediator.normalise(TransformerManager.createWithDefaults(), "value"), is("value"));
    assertThat(atomFieldMediator.normalise(TransformerManager.createWithDefaults(), 1), is("1"));
    assertThat(atomFieldMediator.normalise(TransformerManager.createWithDefaults(), IndexType.Automatic), is("Automatic"));
    assertThat(atomFieldMediator.normalise(TransformerManager.createWithDefaults(), true), is("true"));
}
 

import com.threewks.gaetools.search.gae.meta.IndexType; //导入依赖的package包/类
@Test
public void shouldNormaliseDifferentTypes() {
    assertThat(mediator.normalise(TransformerManager.createWithDefaults(), "value"), is("value"));
    assertThat(mediator.normalise(TransformerManager.createWithDefaults(), 1), is("1"));
    assertThat(mediator.normalise(TransformerManager.createWithDefaults(), IndexType.Automatic), is("Automatic"));
    assertThat(mediator.normalise(TransformerManager.createWithDefaults(), true), is("true"));
}
 

import com.threewks.gaetools.search.gae.meta.IndexType; //导入依赖的package包/类
@Test
public void shouldHaveAMediatorForEachIndexTypeByDefault() {
    FieldMediatorSet fieldMediatorSet = new FieldMediatorSet();
    for (IndexType indexType : IndexType.values()) {
        assertThat(fieldMediatorSet.get(indexType), is(notNullValue()));
    }
}
 

import com.threewks.gaetools.search.gae.meta.IndexType; //导入依赖的package包/类
@Test
public void shouldFailIfAFieldMediatorIsMissing() {
    thrown.expect(SearchException.class);
    thrown.expectMessage("No FieldMediator present for IndexType 'Automatic'");

    FieldMediatorSet fieldMediatorSet = new FieldMediatorSet();
    FieldMediator<?> fieldMediator = fieldMediatorSet.get(IndexType.Automatic);
    assertThat(fieldMediator, is(notNullValue()));

    fieldMediatorSet.put(IndexType.Automatic, null);

    fieldMediator = fieldMediatorSet.get(IndexType.Automatic);
    assertThat(fieldMediator, is(nullValue()));
}
 

import com.threewks.gaetools.search.gae.meta.IndexType; //导入依赖的package包/类
@SuppressWarnings("unchecked")
@Test
public void shouldAllowReplacementOfFieldMediator() {
    FieldMediatorSet fieldMediatorSet = new FieldMediatorSet();
    FieldMediator<Object> mediator = mock(FieldMediator.class);
    fieldMediatorSet.put(IndexType.BigDecimal, mediator);

    assertThat(fieldMediatorSet.get(IndexType.BigDecimal), is(mediator));
}
 

import com.threewks.gaetools.search.gae.meta.IndexType; //导入依赖的package包/类
@Test
public void shouldTransformEnumFromStringUsingBestTransformer() {
    ETransformer<? super String, ? extends IndexType> transformer = transformerManager.getBestTransformer(String.class, IndexType.class);
    assertThat(transformer, is(notNullValue()));

    assertThat(transformer.from("Automatic"), is(IndexType.Automatic));
    assertThat(transformer.from("automatic"), is(IndexType.Automatic));
    assertThat(transformer.from("AUTOMATIC"), is(IndexType.Automatic));

}
 

import com.threewks.gaetools.search.gae.meta.IndexType; //导入依赖的package包/类
@Test
public void shouldTransformObjectToEnum() {
    ETransformer<? super Object, ? extends IndexType> transformer = transformerManager.getTransformer(Object.class, IndexType.class);
    assertThat(transformer, is(notNullValue()));

    assertThat(transformer.from("Automatic"), is(IndexType.Automatic));
    assertThat(transformer.from("automatic"), is(IndexType.Automatic));
    assertThat(transformer.from("AUTOMATIC"), is(IndexType.Automatic));
}