Example usage for com.google.common.collect ContiguousSet create

Introduction

In this page you can find the example usage for com.google.common.collect ContiguousSet create.

Prototype

public static <C extends Comparable> ContiguousSet<C> create(Range<C> range, DiscreteDomain<C> domain)

Source Link

Document

Returns a ContiguousSet containing the same values in the given domain Range#contains contained by the range.

Usage

From source file:org.apache.calcite.chinook.PreferredAlbumsTableFactory.java

private Queryable<Integer> fetchPreferredAlbums() {
    if (EnvironmentFairy.getUser() == EnvironmentFairy.User.SPECIFIC_USER) {
        return Linq4j.asEnumerable(SPECIFIC_USER_PREFERRED_ALBUMS).asQueryable();
    } else {//from  ww w .j a  va2 s.  c o m
        final ContiguousSet<Integer> set = ContiguousSet.create(Range.closed(FIRST_ID, LAST_ID),
                DiscreteDomain.integers());
        return Linq4j.asEnumerable(set).asQueryable();
    }
}

From source file:com.cognifide.aet.job.common.datafilters.removelines.RemoveLinesDataModifier.java

private Set<Integer> extractIndexes(String dataRanges) throws ParametersException {
    Set<Integer> indexesToRemove = new HashSet<Integer>();
    if (dataRanges != null) {
        for (String range : dataRanges.split(";")) {
            try {
                String[] split = range.split(",");
                indexesToRemove.addAll(//from  www .  java 2  s.c om
                        ContiguousSet.create(Range.closed(Integer.valueOf(split[0]), Integer.valueOf(split[1])),
                                DiscreteDomain.integers()));
            } catch (IllegalArgumentException e) {
                throw new ParametersException("Bad range: " + range, e);
            }
        }
    }
    return indexesToRemove;
}

From source file:com.comphenix.protocol.RangeParser.java

/**
 * Simplify a list of ranges by assuming a maximum value.
 * @param ranges - the list of ranges to simplify.
 * @param maximum - the maximum value (minimum value is always 0).
 * @return A simplified list of ranges.//  w ww  . j  av a  2 s .  co  m
 */
private static List<Range<Integer>> simplify(List<Range<Integer>> ranges, int maximum) {
    List<Range<Integer>> result = new ArrayList<Range<Integer>>();
    boolean[] set = new boolean[maximum + 1];
    int start = -1;

    // Set every ID
    for (Range<Integer> range : ranges) {
        for (int id : ContiguousSet.create(range, DiscreteDomain.integers())) {
            set[id] = true;
        }
    }

    // Generate ranges from this set
    for (int i = 0; i <= set.length; i++) {
        if (i < set.length && set[i]) {
            if (start < 0) {
                start = i;
            }
        } else {
            if (start >= 0) {
                result.add(Range.closed(start, i - 1));
                start = -1;
            }
        }
    }

    return result;
}

From source file:com.reimed.guid.client.pii.validation.GreogorianBirthdayConstraint.java

private ContiguousSet<Integer> range(int start, int end) {
    return ContiguousSet.create(Range.closed(start, end), DiscreteDomain.integers());
}

From source file:io.techcode.velox.math.FastMath.java

/**
 * Returns a random number value defined by the range.
 *
 * @param range  range definition./*from w w w. ja v  a2 s . c om*/
 * @param domain domain definition.
 * @param <T>    type of the value.
 * @return random number value.
 */
public static <T extends Comparable> T randomGeneric(Range<T> range, DiscreteDomain<T> domain) {
    ContiguousSet<T> set = ContiguousSet.create(range, domain);
    return set.asList().get(new Random().nextInt(set.size()));
}

From source file:org.locationtech.geogig.osm.internal.history.HistoryDownloader.java

/**
 * @return the next available changeset, or absent if reached the last one
 * @throws IOException//from  w  w w . j av  a 2  s.c o  m
 * @throws InterruptedException
 */
public Iterator<Changeset> fetchChangesets() {

    Range<Long> range = Range.closed(initialChangeset, finalChangeset);
    ContiguousSet<Long> changesetIds = ContiguousSet.create(range, DiscreteDomain.longs());
    final int fetchSize = 100;
    Iterator<List<Long>> partitions = Iterators.partition(changesetIds.iterator(), fetchSize);

    Function<List<Long>, Iterator<Changeset>> asChangesets = new Function<List<Long>, Iterator<Changeset>>() {
        @Override
        public Iterator<Changeset> apply(List<Long> batchIds) {

            Iterable<Changeset> changesets = downloader.fetchChangesets(batchIds);

            for (Changeset changeset : changesets) {
                if (filter.apply(changeset)) {
                    Supplier<Optional<File>> changesFile;
                    changesFile = downloader.fetchChanges(changeset.getId());
                    Supplier<Optional<Iterator<Change>>> changes = new ChangesSupplier(changesFile);
                    changeset.setChanges(changes);
                }
            }

            return changesets.iterator();
        }
    };

    Iterator<Iterator<Changeset>> changesets = Iterators.transform(partitions, asChangesets);
    Iterator<Changeset> concat = Iterators.concat(changesets);
    return concat;
}

From source file:com.google.errorprone.refaster.UBlank.java

@Override
public Choice<UnifierWithUnconsumedStatements> apply(final UnifierWithUnconsumedStatements state) {
    int goodIndex = 0;
    while (goodIndex < state.unconsumedStatements().size()) {
        StatementTree stmt = state.unconsumedStatements().get(goodIndex);
        if (firstNonNull(FORBIDDEN_REFERENCE_SCANNER.scan(stmt, state.unifier()), false)
                && ControlFlowVisitor.INSTANCE.visitStatement(stmt) == ControlFlowVisitor.Result.NEVER_EXITS) {
            break;
        } else {/*from w w w  .  ja v  a2 s  . com*/
            goodIndex++;
        }
    }
    Collection<Integer> breakPoints = ContiguousSet.create(Range.closed(0, goodIndex),
            DiscreteDomain.integers());
    return Choice.from(breakPoints).transform(new Function<Integer, UnifierWithUnconsumedStatements>() {
        @Override
        public UnifierWithUnconsumedStatements apply(Integer k) {
            Unifier unifier = state.unifier().fork();
            unifier.putBinding(key(), state.unconsumedStatements().subList(0, k));
            List<? extends StatementTree> remaining = state.unconsumedStatements().subList(k,
                    state.unconsumedStatements().size());
            return UnifierWithUnconsumedStatements.create(unifier, remaining);
        }
    });
}

From source file:org.caleydo.view.crossword.api.ui.band.Route.java

private Iterable<Vec2f> shiftCurve(final IDoubleFunction radius) {
    final int last = curve.length - 1;
    final float distanceFactor = 1.f / distances[last];
    return Iterables.transform(ContiguousSet.create(Range.closed(0, last), DiscreteDomain.integers()),
            new Function<Integer, Vec2f>() {
                @Override// w  w  w.j av  a  2s.com
                public Vec2f apply(Integer input) {
                    int i = input.intValue();

                    final float t = distances[i] * distanceFactor;
                    final float r = (float) radius.apply(t);

                    Vec2f p = curve[i].addScaled(r, normals[i]);
                    return p;
                }
            });
}

From source file:org.obm.push.minig.imap.impl.ImapMessageSet.java

private String rangeAsString(Range<Long> range) {
    ContiguousSet<Long> rangeAsSet = ContiguousSet.create(range, DiscreteDomain.longs());
    if (rangeAsSet.size() == 1) {
        return singleValueRangeAsString(rangeAsSet);
    } else {//from  w  w w  . j av  a 2 s .  c om
        return intervalRangeAsString(rangeAsSet);
    }
}

From source file:sklearn.preprocessing.OneHotEncoder.java

public List<? extends Number> getValues() {
    List<Integer> featureSizes = getFeatureSizes();

    if (featureSizes.size() != 1) {
        throw new IllegalArgumentException();
    }/*from www.  j a  va 2s  .  c  o  m*/

    Object numberOfValues = get("n_values");

    if (("auto").equals(numberOfValues)) {
        return getActiveFeatures();
    }

    Integer featureSize = featureSizes.get(0);

    List<Integer> result = new ArrayList<>();
    result.addAll(ContiguousSet.create(Range.closedOpen(0, featureSize), DiscreteDomain.integers()));

    return result;
}