Function indexer for Gigamap?

[hrstoyanov]

@fh-ms please take a look at this :

public class IndexerFunctional<E,K> extends Indexer.Abstract<E, K>{

    private final Function<E, K> keyExtractor;
    private final Class<K> keyClass;
    private final String name;

    public IndexerFunctional(String name, Class<K> keyClass, Function<E, K> keyExtractor){
        this.keyExtractor = Objects.requireNonNull(keyExtractor, "keyExtractor is null");
        this.keyClass = Objects.requireNonNull(keyClass, "keyClass is null");
        this.name = name;
    }

    public IndexerFunctional(Class<K> keyClass, Function<E, K> keyExtractor){
        this(null,keyClass,keyExtractor);
    }

    @Override
    public  String name(){
        return isEmptyOrNull(name) ? super.name(): name;
    }

    @Override
    public Class<K> keyType() {
        return keyClass;
    }

    @Override
    public K index(E entity) {
        return keyExtractor.apply(entity);
    }

This allows for very compact definitions of indexers:

static final Indexer<Business, UUID> BUSINESS_BY_ID_IND = new  IndexerFunctional <> (UUID.class, Business::id);
static final Indexer<Business, String> BUSINESS_BY_NAME_IND = new  IndexerFunctional <> (String.class, Business::name);
static final Indexer<Business, UUID> BUSINESS_BY_PARENT_ID_IND = new  IndexerFunctional <> (UUID.class, b -> b.parent().id());

I called it "IndexerFunctional" because in Oracle there is a similar concept of "functional indexes", but any name will do.

[hrstoyanov]

I see some issues though - ES thinks the below 2 indexers are the the same:

static final Indexer<Business, UUID> BUSINESS_BY_ID_IND = new  IndexerFunctional <> (UUID.class, Business::id);
static final Indexer<Business, UUID> BUSINESS_BY_PARENT_ID_IND = new  IndexerFunctional <> (UUID.class, b -> b.parent().id());

It will not do that mistake with the anonymous class variant, where the anonymous classes are unique and different. Should the indexes be differentiated by their names in addition to types?

[hrstoyanov]

Ok, issue confirmed. To make it work one can do this (which is weird):

static final Indexer<Business, UUID> BUSINESS_BY_ID_IND = new  IndexerFunctional <> (UUID.class, Business::id){};
static final Indexer<Business, UUID> BUSINESS_BY_PARENT_ID_IND = new  IndexerFunctional <> (UUID.class, b -> b.parent().id()){};

[hrstoyanov]

@fh-ms - Another minor issue is with binary indexers - consider the below indexer for Tsid key type : Sometimes indexBinary must return 0 - for example if you want to index an entity by its parent entity id. For the top one, there is no "parent entity id" and one would like to return 0 in indexBinary. Since this generates an exception , I am forced to return Long.MAX_VALUE, which is ... akward.

Also see #476 - why is there a restriction on positive longs only?

public class IndexerTsidBinaryFunctional<E> extends BinaryIndexer.Abstract<E> {

    private final Function<E, Tsid> tsidExtractor;
    private final String name;

    public IndexerTsidBinaryFunctional(String name, Function<E, Tsid> tsidExtractor) {
        this.tsidExtractor = requireNonNull(tsidExtractor, "Tsid extractor is null");
        this.name = name;
    }

    public IndexerTsidBinaryFunctional(Function<E, Tsid> tsidExtractor) {
        this(null, tsidExtractor);
    }

    @Override
    public String name() {
        return isNotEmptyOrNull(name) ? name : super.name();
    }

    public final long indexBinary(final E entity) {
        var tsid = tsidExtractor.apply(entity);
        return tsid != null ? tsid.toLong() : Long.MAX_VALUE;
    }

    public <S extends E> Condition<S> is(final Tsid id) {
        return super.is(id.toLong());
    }
}

[hrstoyanov]

Ugh .. just realized the whole concept is pointless - because of functional types, such indexers cannot be persited (as part of the gigamap instance)