Example usage for org.apache.lucene.document FieldType omitNorms

Introduction

In this page you can find the example usage for org.apache.lucene.document FieldType omitNorms.

Prototype

boolean omitNorms

To view the source code for org.apache.lucene.document FieldType omitNorms.

Click Source Link

Usage

From source file:com.sindicetech.siren.solr.schema.ExtendedJsonField.java

License:Open Source License

@Override
protected IndexableField createField(final String name, final String val,
        final org.apache.lucene.document.FieldType type, final float boost) {

    if (!type.indexed()) {
        throw new SolrException(SolrException.ErrorCode.SERVER_ERROR,
                "ExtendedJsonField instances must be indexed: " + name);
    }/*from  ww w  .  jav a  2s .c o m*/
    if (!type.tokenized()) {
        throw new SolrException(SolrException.ErrorCode.SERVER_ERROR,
                "ExtendedJsonField instances must be tokenised: " + name);
    }
    if (!type.omitNorms()) {
        throw new SolrException(SolrException.ErrorCode.SERVER_ERROR,
                "ExtendedJsonField instances must omit norms: " + name);
    }
    if (!type.indexOptions().equals(IndexOptions.DOCS_AND_FREQS_AND_POSITIONS)) {
        throw new SolrException(SolrException.ErrorCode.SERVER_ERROR,
                "ExtendedJsonField instances must not omit term " + "frequencies and positions: " + name);
    }
    if (type.storeTermVectors()) {
        throw new SolrException(SolrException.ErrorCode.SERVER_ERROR,
                "ExtendedJsonField instances can not store term vectors: " + name);
    }

    return super.createField(name, val, type, boost);
}

---

From source file:org.apache.solr.schema.CurrencyField.java

License:Apache License

@Override
public List<IndexableField> createFields(SchemaField field, Object externalVal, float boost) {
    CurrencyValue value = CurrencyValue.parse(externalVal.toString(), defaultCurrency);

    List<IndexableField> f = new ArrayList<IndexableField>();
    SchemaField amountField = getAmountField(field);
    f.add(amountField.createField(String.valueOf(value.getAmount()),
            amountField.indexed() && !amountField.omitNorms() ? boost : 1F));
    SchemaField currencyField = getCurrencyField(field);
    f.add(currencyField.createField(value.getCurrencyCode(),
            currencyField.indexed() && !currencyField.omitNorms() ? boost : 1F));

    if (field.stored()) {
        org.apache.lucene.document.FieldType customType = new org.apache.lucene.document.FieldType();
        assert !customType.omitNorms();
        customType.setStored(true);/*from www  .  j av  a 2 s.c  o  m*/
        String storedValue = externalVal.toString().trim();
        if (storedValue.indexOf(",") < 0) {
            storedValue += "," + defaultCurrency;
        }
        f.add(createField(field.getName(), storedValue, customType, 1F));
    }

    return f;
}

---

From source file:org.elasticsearch.index.mapper.core.AbstractFieldMapper.java

License:Apache License

protected void doXContentBody(XContentBuilder builder, boolean includeDefaults, Params params)
        throws IOException {

    builder.field("type", contentType());
    if (includeDefaults || !names.name().equals(names.indexNameClean())) {
        builder.field("index_name", names.indexNameClean());
    }/*  ww w  .  ja  v a 2s . c  o  m*/

    if (includeDefaults || boost != 1.0f) {
        builder.field("boost", boost);
    }

    FieldType defaultFieldType = defaultFieldType();
    if (includeDefaults || fieldType.indexed() != defaultFieldType.indexed()
            || fieldType.tokenized() != defaultFieldType.tokenized()) {
        builder.field("index", indexTokenizeOptionToString(fieldType.indexed(), fieldType.tokenized()));
    }
    if (includeDefaults || fieldType.stored() != defaultFieldType.stored()) {
        builder.field("store", fieldType.stored());
    }
    if (includeDefaults || hasDocValues() != Defaults.DOC_VALUES) {
        builder.field(TypeParsers.DOC_VALUES, docValues);
    }
    if (includeDefaults || fieldType.storeTermVectors() != defaultFieldType.storeTermVectors()) {
        builder.field("term_vector", termVectorOptionsToString(fieldType));
    }
    if (includeDefaults || fieldType.omitNorms() != defaultFieldType.omitNorms() || normsLoading != null) {
        builder.startObject("norms");
        if (includeDefaults || fieldType.omitNorms() != defaultFieldType.omitNorms()) {
            builder.field("enabled", !fieldType.omitNorms());
        }
        if (normsLoading != null) {
            builder.field(Loading.KEY, normsLoading);
        }
        builder.endObject();
    }
    if (includeDefaults || fieldType.indexOptions() != defaultFieldType.indexOptions()) {
        builder.field("index_options", indexOptionToString(fieldType.indexOptions()));
    }

    if (indexAnalyzer == null && searchAnalyzer == null) {
        if (includeDefaults) {
            builder.field("analyzer", "default");
        }
    } else if (indexAnalyzer == null) {
        // searchAnalyzer != null
        if (includeDefaults
                || (!searchAnalyzer.name().startsWith("_") && !searchAnalyzer.name().equals("default"))) {
            builder.field("search_analyzer", searchAnalyzer.name());
        }
    } else if (searchAnalyzer == null) {
        // indexAnalyzer != null
        if (includeDefaults
                || (!indexAnalyzer.name().startsWith("_") && !indexAnalyzer.name().equals("default"))) {
            builder.field("index_analyzer", indexAnalyzer.name());
        }
    } else if (indexAnalyzer.name().equals(searchAnalyzer.name())) {
        // indexAnalyzer == searchAnalyzer
        if (includeDefaults
                || (!indexAnalyzer.name().startsWith("_") && !indexAnalyzer.name().equals("default"))) {
            builder.field("analyzer", indexAnalyzer.name());
        }
    } else {
        // both are there but different
        if (includeDefaults
                || (!indexAnalyzer.name().startsWith("_") && !indexAnalyzer.name().equals("default"))) {
            builder.field("index_analyzer", indexAnalyzer.name());
        }
        if (includeDefaults
                || (!searchAnalyzer.name().startsWith("_") && !searchAnalyzer.name().equals("default"))) {
            builder.field("search_analyzer", searchAnalyzer.name());
        }
    }

    if (postingsFormat != null) {
        if (includeDefaults || !postingsFormat.name().equals(defaultPostingFormat())) {
            builder.field("postings_format", postingsFormat.name());
        }
    } else if (includeDefaults) {
        String format = defaultPostingFormat();
        if (format == null) {
            format = PostingsFormatService.DEFAULT_FORMAT;
        }
        builder.field("postings_format", format);
    }

    if (docValuesFormat != null) {
        if (includeDefaults || !docValuesFormat.name().equals(defaultDocValuesFormat())) {
            builder.field(DOC_VALUES_FORMAT, docValuesFormat.name());
        }
    } else if (includeDefaults) {
        String format = defaultDocValuesFormat();
        if (format == null) {
            format = DocValuesFormatService.DEFAULT_FORMAT;
        }
        builder.field(DOC_VALUES_FORMAT, format);
    }

    if (similarity() != null) {
        builder.field("similarity", similarity().name());
    } else if (includeDefaults) {
        builder.field("similariry", SimilarityLookupService.DEFAULT_SIMILARITY);
    }

    if (customFieldDataSettings != null) {
        builder.field("fielddata", (Map) customFieldDataSettings.getAsMap());
    } else if (includeDefaults) {
        builder.field("fielddata", (Map) fieldDataType.getSettings().getAsMap());
    }
    multiFields.toXContent(builder, params);

    if (copyTo != null) {
        copyTo.toXContent(builder, params);
    }
}

---

From source file:org.hibernate.search.test.util.SerializationTestHelper.java

License:LGPL

private static void assertFieldType(FieldType copy, FieldType original) {
    assertThat(copy.omitNorms()).isEqualTo(original.omitNorms());
    assertThat(copy.storeTermVectorOffsets()).isEqualTo(original.storeTermVectorOffsets());
    assertThat(copy.storeTermVectorPayloads()).isEqualTo(original.storeTermVectorPayloads());
    assertThat(copy.storeTermVectorOffsets()).isEqualTo(original.storeTermVectorOffsets());
    assertThat(copy.docValuesType()).isEqualTo(original.docValuesType());
    assertThat(copy.indexOptions()).isEqualTo(original.indexOptions());
    assertThat(copy.numericPrecisionStep()).isEqualTo(original.numericPrecisionStep());
    assertThat(copy.numericType()).isEqualTo(original.numericType());
    assertThat(copy.stored()).isEqualTo(original.stored());
    assertThat(copy.storeTermVectors()).isEqualTo(original.storeTermVectors());
    assertThat(copy.tokenized()).isEqualTo(original.tokenized());
    assertThat(copy.toString()).isEqualTo(original.toString());
}

---