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:io.v.todos.persistence.syncbase.DigitMappings.java

/**
 * Constructs a {@link DigitMapping} from a {@link RangeSet}, ordering the ranges in ascending
 * order (regardless of input order). If out-of-order ranges are desired, use the
 * {@link #fromRanges(Iterable)} factory method instead to provide explicit ordering.
 *///from   ww  w .j av a2s .  co m
public static DigitMapping fromRangeSet(RangeSet<Character> spec) {
    return fromRanges(
            Collections2.transform(spec.asRanges(), new Function<Range<Character>, ContiguousSet<Character>>() {
                @Override
                public ContiguousSet<Character> apply(Range<Character> input) {
                    return ContiguousSet.create(input, DOMAIN);
                }
            }));
}

---

From source file:crud.http.util.FailedResponseOperator.java

/**
 * Treat all 500-range responses as errors.
 *//*from w ww  .j a va2  s . c  o m*/
public static FailedResponseOperator serverErrors() {
    if (serverErrors == null) {
        // Don't delegate to fromStatusCodes(): it does extraneous checking
        serverErrors = new FailedResponseOperator(
                ContiguousSet.create(Range.closed(MIN_SERVER_ERROR_STATUS_CODE, MAX_SERVER_ERROR_STATUS_CODE),
                        DiscreteDomain.integers()));
    }
    return serverErrors;
}

---

From source file:com.google.cloud.genomics.dataflow.utils.PairGenerator.java

/**
 * * Generates all combinations (not permutations) of pairs of the elements in the iterable.
 *
 * The pairs are often used as keys for results in many n^2 analyses where we end up with
 * (n*(n-1))/2 or ((n*(n-1))/2)+n results.
 *
 * @param list/*from w ww  .  ja v  a 2 s.  c om*/
 * @param comparator - used to enforce an order upon the elements within each pair
 * @return the pairs
 */
public <X, L extends List<? extends X> & RandomAccess> FluentIterable<KV<X, X>> allPairs(final L list,
        final Comparator<? super X> comparator) {
    return FluentIterable
            .from(ContiguousSet.create(Range.closedOpen(0, list.size()), DiscreteDomain.integers()))
            .transformAndConcat(new Function<Integer, Iterable<KV<X, X>>>() {
                @Override
                public Iterable<KV<X, X>> apply(final Integer i) {
                    return new Iterable<KV<X, X>>() {
                        @Override
                        public Iterator<KV<X, X>> iterator() {
                            int iteratorIndex = i;
                            if (!withReplacement) {
                                iteratorIndex++;
                            }
                            return Iterators.transform(list.listIterator(iteratorIndex),
                                    new Function<X, KV<X, X>>() {

                                        private final X key = list.get(i);

                                        @Override
                                        public KV<X, X> apply(X value) {
                                            boolean swap = 0 < comparator.compare(key, value);
                                            return KV.of(swap ? value : key, swap ? key : value);
                                        }
                                    });
                        }
                    };
                }
            });
}

---

From source file:com.nitayjoffe.util.ranges.Range2D.java

private Range2D(Range<Integer> range1, Range<Integer> range2) {
    set1 = ContiguousSet.create(range1, integers());
    set2 = ContiguousSet.create(range2, integers());
}

---

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

private static Function<UnifierWithRemainingMembers, Choice<UnifierWithRemainingMembers>> match(
        final Tree tree) {
    return new Function<UnifierWithRemainingMembers, Choice<UnifierWithRemainingMembers>>() {
        @Override/*  w  w w.j av a  2  s .c o m*/
        public Choice<UnifierWithRemainingMembers> apply(final UnifierWithRemainingMembers state) {
            final ImmutableList<UMethodDecl> currentMembers = state.remainingMembers();
            Choice<Integer> methodChoice = Choice.from(ContiguousSet
                    .create(Range.closedOpen(0, currentMembers.size()), DiscreteDomain.integers()));
            return methodChoice.thenChoose(new Function<Integer, Choice<UnifierWithRemainingMembers>>() {
                @Override
                public Choice<UnifierWithRemainingMembers> apply(Integer i) {
                    ImmutableList<UMethodDecl> remainingMembers = new ImmutableList.Builder<UMethodDecl>()
                            .addAll(currentMembers.subList(0, i))
                            .addAll(currentMembers.subList(i + 1, currentMembers.size())).build();
                    UMethodDecl chosenMethod = currentMembers.get(i);
                    Unifier unifier = state.unifier().fork();
                    /* 
                     * If multiple methods use the same parameter name, preserve the last parameter
                     * name from the target code.  For example, given a @BeforeTemplate with
                     * 
                     *    int get(int index) {...}
                     *    int set(int index, int value) {...}
                     *    
                     * and target code with the lines
                     * 
                     *    int get(int i) {...}
                     *    int set(int j) {...}
                     *    
                     * then use "j" in place of index in the @AfterTemplates.
                     */
                    for (UVariableDecl param : chosenMethod.getParameters()) {
                        unifier.clearBinding(param.key());
                    }
                    return chosenMethod.unify(tree, unifier)
                            .transform(UnifierWithRemainingMembers.withRemaining(remainingMembers));
                }
            });
        }
    };
}

---

From source file:edu.mit.streamjit.test.Datasets.java

public static Dataset allIntsInRange(Range<Integer> range) {
    return fromIterable(range.toString(), ContiguousSet.create(range, DiscreteDomain.integers()));
}

---

From source file:crud.http.util.FailedResponseOperator.java

/**
 * Treat all non-200-range responses as errors.
 *///from   ww w . java2 s  . c  om
public static FailedResponseOperator nonSuccessResponses() {
    if (nonSuccessResponses == null) {
        final ImmutableSet<Integer> prefix = ContiguousSet
                .create(Range.closedOpen(MIN_STATUS_CODE, MIN_SUCCESS_STATUS_CODE), DiscreteDomain.integers());
        final ImmutableSet<Integer> suffix = ContiguousSet
                .create(Range.openClosed(MAX_SUCCESS_STATUS_CODE, MAX_STATUS_CODE), DiscreteDomain.integers());
        final ImmutableSet<Integer> all = ImmutableSet.<Integer>builder().addAll(prefix).addAll(suffix).build();
        // Don't delegate to fromStatusCodes(): it does extraneous checking
        nonSuccessResponses = new FailedResponseOperator(all);
    }
    return nonSuccessResponses;
}

---

From source file:cz.cuni.mff.ms.brodecva.botnicek.ide.compile.library.Randomize.java

private static List<List<TemplateElement>> createChoices(final int starsCount) {
    final ImmutableList.Builder<List<TemplateElement>> builder = ImmutableList.builder();

    final String space = AIML.WORD_DELIMITER.getValue();
    final String randomStart = RANDOM_START;
    final String randomEnd = RANDOM_END;

    final ImmutableSortedSet<Integer> set = ContiguousSet.create(Range.closed(1, starsCount),
            DiscreteDomain.integers());//  w w w  .j  a  v a2 s.c  om

    for (int picked = 1; picked <= starsCount; picked++) {
        final Star pickedStar = Star.create(new AIMLIndex(picked));
        final SetView<Integer> rest = Sets.difference(set, ImmutableSet.of(picked));

        // @formatter:off
        // <li><star index="3"/> <srai>RANDOMSTART <srai>REMOVESTART <star index="3"/> <star index="1"/> <star index="2"/> <star index="4"/> REMOVEEND</srai> RANDOMEND</srai><li>
        builder.add(ImmutableList.<TemplateElement>of(pickedStar, Text.create(space),
                Srai.create(Text.create(randomStart + space), Srai.create(removeCopies(pickedStar, rest)),
                        Text.create(space + randomEnd))));
        // @formatter:on
    }

    return builder.build();
}

---

From source file:google.registry.model.ofy.CommitLogBucket.java

/** Returns a sorted set of all the possible numeric bucket IDs. */
public static ImmutableSortedSet<Integer> getBucketIds() {
    return ContiguousSet.create(getBucketIdRange(), integers());
}

---

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

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

---

• «
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• »