org.aksw.commons.collection.rangeset.ConvertingRangeSet Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of aksw-commons-collections Show documentation
There is a newer version: 0.9.9
Show newest version
package org.aksw.commons.collection.rangeset;

import java.util.Set;

import org.aksw.commons.collections.ConvertingSet;
import org.aksw.commons.util.range.RangeUtils;

import com.google.common.base.Converter;
import com.google.common.collect.Range;
import com.google.common.collect.RangeSet;

public class ConvertingRangeSet, U extends Comparable>
    implements RangeSet
{
    // Convert from wrapped view to public view
    protected Converter endpointConverter;
    protected Converter, Range> rangeConverter;

    protected RangeSet backend;


    public static , O extends Comparable> Converter, Range> createRangeConverter(Converter endpointConverter) {
        return Converter.from(
               (Range a) -> RangeUtils.map(a, endpointConverter::convert),
               (Range b) -> RangeUtils.map(b, endpointConverter.reverse()::convert));
    }


    public ConvertingRangeSet(RangeSet backend, Converter endpointConverter) {
        this(backend, endpointConverter, createRangeConverter(endpointConverter));
    }


    public ConvertingRangeSet(RangeSet backend, Converter endpointConverter,
            Converter, Range> rangeConverter) {
        super();
        this.backend = backend;
        this.endpointConverter = endpointConverter;
        this.rangeConverter = rangeConverter;
    }


    // public static T extends Comparable, U extends Comparable map()

    @Override
    public boolean contains(T value) {
        U v = endpointConverter.reverse().convert(value);
        boolean result = backend.contains(v);
        return result;
    }

    @Override
    public Range rangeContaining(T value) {
        U v = endpointConverter.reverse().convert(value);
        Range b = backend.rangeContaining(v);
        Range result = rangeConverter.convert(b);
        return result;
    }

    @Override
    public boolean intersects(Range otherRange) {
        Range or = rangeConverter.reverse().convert(otherRange);
        boolean result = backend.intersects(or);
        return result;
    }

    @Override
    public boolean encloses(Range otherRange) {
        Range or = rangeConverter.reverse().convert(otherRange);
        boolean result = backend.encloses(or);
        return result;
    }

    @Override
    public boolean enclosesAll(RangeSet other) {
        // TODO We could check which set is smaller and apply conversion accordingly
        boolean result = backend.enclosesAll(new ConvertingRangeSet<>(other, endpointConverter.reverse(), rangeConverter.reverse()));
        return result;
    }

    @Override
    public boolean isEmpty() {
        return backend.isEmpty();
    }

    @Override
    public Range span() {
        Range r = backend.span();
        Range result = rangeConverter.convert(r);
        return result;
    }

    @Override
    public Set> asRanges() {
        return new ConvertingSet<>(backend.asRanges(), rangeConverter);
    }

    @Override
    public Set> asDescendingSetOfRanges() {
        return new ConvertingSet<>(backend.asDescendingSetOfRanges(), rangeConverter);
    }

    @Override
    public RangeSet complement() {
        // TODO cache reference
        return new ConvertingRangeSet<>(backend.complement(), endpointConverter, rangeConverter);
    }

    @Override
    public RangeSet subRangeSet(Range view) {
        // TODO Auto-generated method stub
        Range r = rangeConverter.reverse().convert(view);
        return new ConvertingRangeSet<>(backend.subRangeSet(r), endpointConverter, rangeConverter);
    }

    @Override
    public void add(Range range) {
        Range r = rangeConverter.reverse().convert(range);
        backend.add(r);
    }

    @Override
    public void remove(Range range) {
        Range r = rangeConverter.reverse().convert(range);
        backend.remove(r);
    }

    @Override
    public void clear() {
        backend.clear();
    }

    @Override
    public void addAll(RangeSet other) {
        backend.addAll(new ConvertingRangeSet<>(other, endpointConverter.reverse(), rangeConverter.reverse()));
    }

    @Override
    public void removeAll(RangeSet other) {
        backend.removeAll(new ConvertingRangeSet<>(other, endpointConverter.reverse(), rangeConverter.reverse()));
    }

}