Java Indexed类代码示例

import org.mongodb.morphia.annotations.Indexed; //导入依赖的package包/类
@SuppressWarnings("deprecation")
Index convert(final Indexed indexed, final String nameToStore) {
    if (indexed.dropDups() || indexed.options().dropDups()) {
        LOG.warning("Support for dropDups has been removed from the server.  Please remove this setting.");
    }
    final Map<String, Object> newOptions = extractOptions(indexed.options());
    if (!extractOptions(indexed).isEmpty() && !newOptions.isEmpty()) {
        throw new MappingException("Mixed usage of deprecated @Indexed values with the new @IndexOption values is not "
                                       + "allowed.  Please migrate all settings to @IndexOptions");
    }

    List<Field> fields = Collections.<Field>singletonList(new FieldBuilder()
                                                              .value(nameToStore)
                                                              .type(fromValue(indexed.value().toIndexValue())));
    return newOptions.isEmpty()
           ? new IndexBuilder()
               .options(new IndexOptionsBuilder()
                            .migrate(indexed))
               .fields(fields)
           : new IndexBuilder()
               .options(indexed.options())
               .fields(fields);
}
 

import org.mongodb.morphia.annotations.Indexed; //导入依赖的package包/类
@Test
@SuppressWarnings("deprecation")
public void oldIndexedForm() {
    Indexed indexed = new IndexedBuilder()
        .name("index_name")
        .background(true)
        .dropDups(true)
        .expireAfterSeconds(42)
        .sparse(true)
        .unique(true)
        .value(IndexDirection.DESC);
    assertEquals(indexed.options().name(), "");

    Index converted = indexHelper.convert(indexed, "oldstyle");
    assertEquals(converted.options().name(), "index_name");
    assertTrue(converted.options().background());
    assertTrue(converted.options().dropDups());
    assertTrue(converted.options().sparse());
    assertTrue(converted.options().unique());
    assertEquals(new FieldBuilder().value("oldstyle").type(IndexType.DESC), converted.fields()[0]);
}
 

import org.mongodb.morphia.annotations.Indexed; //导入依赖的package包/类
@Test
@SuppressWarnings("deprecation")
public void normalizeIndexed() {
    Indexed indexed = new IndexedBuilder()
        .value(IndexDirection.DESC)
        .options(new IndexOptionsBuilder().name("index_name")
                                          .background(true)
                                          .dropDups(true)
                                          .expireAfterSeconds(42)
                                          .sparse(true)
                                          .unique(true));

    Index converted = indexHelper.convert(indexed, "oldstyle");
    assertEquals(converted.options().name(), "index_name");
    assertTrue(converted.options().background());
    assertTrue(converted.options().dropDups());
    assertTrue(converted.options().sparse());
    assertTrue(converted.options().unique());
    assertEquals(new FieldBuilder().value("oldstyle").type(IndexType.DESC), converted.fields()[0]);
}
 

import org.mongodb.morphia.annotations.Indexed; //导入依赖的package包/类
@SuppressWarnings("deprecation")
private List<Index> collectFieldIndexes(final MappedClass mc) {
    List<Index> list = new ArrayList<Index>();
    for (final MappedField mf : mc.getPersistenceFields()) {
        if (mf.hasAnnotation(Indexed.class)) {
            final Indexed indexed = mf.getAnnotation(Indexed.class);
            list.add(convert(indexed, mf.getNameToStore()));
        } else if (mf.hasAnnotation(Text.class)) {
            final Text text = mf.getAnnotation(Text.class);
            list.add(convert(text, mf.getNameToStore()));
        }
    }
    return list;
}
 

import org.mongodb.morphia.annotations.Indexed; //导入依赖的package包/类
private Map<String, Object> extractOptions(final Indexed indexed) {
    Map<String, Object> map = toMap(indexed);
    if (indexed.options().collation().locale().equals("")) {
        map.remove("options");
    }
    map.remove("value");
    return map;
}
 

import org.mongodb.morphia.annotations.Indexed; //导入依赖的package包/类
@Test
public void builders() throws NoSuchMethodException {
    compareFields(Index.class, IndexBuilder.class);
    compareFields(IndexOptions.class, IndexOptionsBuilder.class);
    compareFields(Indexed.class, IndexedBuilder.class);
    compareFields(Field.class, FieldBuilder.class);
    compareFields(Collation.class, CollationBuilder.class);
    compareFields(Text.class, TextBuilder.class);
    compareFields(Validation.class, ValidationBuilder.class);
}
 

import org.mongodb.morphia.annotations.Indexed; //导入依赖的package包/类
@Test
public void indexedPartialFilters() {
    MongoCollection<Document> collection = getDatabase().getCollection("indexes");
    MappedClass mappedClass = getMorphia().getMapper().getMappedClass(IndexedClass.class);

    Indexed indexed = new IndexedBuilder()
        .options(new IndexOptionsBuilder()
                     .partialFilter("{ name : { $gt : 13 } }"));

    indexHelper.createIndex(collection, mappedClass, indexHelper.convert(indexed, "text"), false);
    findPartialIndex(BasicDBObject.parse(indexed.options().partialFilter()));
}
 

import org.mongodb.morphia.annotations.Indexed; //导入依赖的package包/类
@Override
public Class<Indexed> annotationType() {
    return Indexed.class;
}
 

import org.mongodb.morphia.annotations.Indexed; //导入依赖的package包/类
IndexOptionsBuilder migrate(final Indexed index) {
    putAll(toMap(index));
    return this;
}