Example usage for com.google.common.collect RangeSet encloses

Introduction

In this page you can find the example usage for com.google.common.collect RangeSet encloses.

Prototype

boolean encloses(Range<C> otherRange);

Source Link

Document

Returns true if there exists a member range in this range set which Range#encloses encloses the specified range.

Usage

From source file:org.apache.lens.cube.parse.CandidateUtil.java

/**
 * Returns true is the Candidates cover the entire time range.
 * @param candidates//from ww w.  ja v a2  s  .  c  o m
 * @param startTime
 * @param endTime
 * @return
 */
static boolean isTimeRangeCovered(Collection<Candidate> candidates, Date startTime, Date endTime) {
    RangeSet<Date> set = TreeRangeSet.create();
    for (Candidate candidate : candidates) {
        set.add(Range.range(candidate.getStartTime(), BoundType.CLOSED, candidate.getEndTime(),
                BoundType.OPEN));
    }
    return set.encloses(Range.range(startTime, BoundType.CLOSED, endTime, BoundType.OPEN));
}

---

From source file:org.kiji.schema.impl.cassandra.CassandraKijiPartition.java

/**
 * Convert a set of (start-token, host) pairs into a set of (token-range, host) pairs.
 *
 * Package private for testing./* www.j  a v a2  s  . c o  m*/
 *
 * @param startTokens The set of start tokens with hosts.
 * @return The token corresponding token ranges.
 */
static Map<Range<Long>, InetAddress> getTokenRanges(final SortedMap<Long, InetAddress> startTokens) {

    ImmutableMap.Builder<Range<Long>, InetAddress> tokenRangesBldr = ImmutableMap.builder();

    final PeekingIterator<Entry<Long, InetAddress>> startTokensItr = Iterators
            .peekingIterator(startTokens.entrySet().iterator());

    // Add a range for [-, firstStartToken) owned by the final key (the wrap-around range).
    // For more information on Casandra VNode token ranges:
    //    http://www.datastax.com/dev/blog/virtual-nodes-in-cassandra-1-2
    tokenRangesBldr.put(Range.lessThan(startTokens.firstKey()), startTokens.get(startTokens.lastKey()));

    while (startTokensItr.hasNext()) {
        Entry<Long, InetAddress> startToken = startTokensItr.next();
        if (!startTokensItr.hasNext()) {
            // The final start token
            // Add a range for [lastStartToken, )
            tokenRangesBldr.put(Range.atLeast(startToken.getKey()), startToken.getValue());
        } else {
            // Add a range for [thisStartToken, nextStartToken)
            tokenRangesBldr.put(Range.closedOpen(startToken.getKey(), startTokensItr.peek().getKey()),
                    startToken.getValue());
        }
    }

    final Map<Range<Long>, InetAddress> tokenRanges = tokenRangesBldr.build();

    // Check that the returned ranges are coherent; most importantly that all possible tokens fall
    // within the returned range set.

    if (startTokens.size() + 1 != tokenRanges.size()) {
        throw new InternalKijiError(
                String.format("Unexpected number of token ranges. start-tokens: %s, token-ranges: %s.",
                        startTokens.size(), tokenRanges.size()));
    }

    final RangeSet<Long> ranges = TreeRangeSet.create();
    for (Range<Long> tokenRange : tokenRanges.keySet()) {
        ranges.add(tokenRange);
    }

    if (!ranges.encloses(Range.closed(Long.MIN_VALUE, Long.MAX_VALUE))) {
        throw new InternalKijiError("Token range does not include all possible tokens.");
    }

    return tokenRanges;
}

---

From source file:org.apache.aurora.scheduler.cron.CrontabEntry.java

private String fieldToString(RangeSet<Integer> rangeSet, Range<Integer> coveringRange) {
    if (rangeSet.asRanges().size() == 1 && rangeSet.encloses(coveringRange)) {
        return "*";
    }/*  www  .j a v a2 s  .  c  o m*/
    List<String> components = Lists.newArrayList();
    for (Range<Integer> range : rangeSet.asRanges()) {
        ContiguousSet<Integer> set = ContiguousSet.create(range, DiscreteDomain.integers());
        if (set.size() == 1) {
            components.add(set.first().toString());
        } else {
            components.add(set.first() + "-" + set.last());
        }
    }
    return String.join(",", components);
}

---

From source file:edu.cmu.lti.oaqa.baseqa.abstract_query.TokenConceptAbstractQueryGenerator.java

@Override
public void process(JCas jcas) throws AnalysisEngineProcessException {
    Collection<Concept> concepts = TypeUtil.getConcepts(jcas);
    List<QueryConcept> qconcepts = ConceptAbstractQueryGenerator.createQueryConceptsFromConceptMentions(jcas,
            concepts, useType, useWeight);
    // filter tokens that are covered by concept mentions
    RangeSet<Integer> cmentionRanges = TreeRangeSet.create();
    concepts.stream().map(TypeUtil::getConceptMentions).flatMap(Collection::stream)
            .map(cmention -> Range.closedOpen(cmention.getBegin(), cmention.getEnd()))
            .forEach(cmentionRanges::add);
    // create an aquery using all tokens with POS in posTags set
    List<Token> tokens = TypeUtil.getOrderedTokens(jcas).stream()
            .filter(token -> !cmentionRanges.encloses(Range.closedOpen(token.getBegin(), token.getEnd())))
            .collect(toList());/*from   w  w w  . ja va 2  s. c o m*/
    List<QueryConcept> qconceptTokens = TokenSelectionAbstractQueryGenerator.createQueryConceptsFromTokens(jcas,
            tokens, posTags, stoplist);
    qconceptTokens.addAll(qconcepts);
    AbstractQuery aquery = TypeFactory.createAbstractQuery(jcas, qconceptTokens);
    aquery.addToIndexes();
    // create a backup aquery using only nouns
    List<QueryConcept> qconceptNouns = TokenSelectionAbstractQueryGenerator.createQueryConceptsFromTokens(jcas,
            tokens, nounTags, stoplist);
    qconceptNouns.addAll(qconcepts);
    AbstractQuery aqueryNoun = TypeFactory.createAbstractQuery(jcas, qconceptNouns);
    aqueryNoun.addToIndexes();
}

---

From source file:com.google.googlejavaformat.java.SnippetFormatter.java

/** Runs the Google Java formatter on the given source, with only the given ranges specified. */
public List<Replacement> format(SnippetKind kind, String source, List<Range<Integer>> ranges, int initialIndent,
        boolean includeComments) throws FormatterException {
    RangeSet<Integer> rangeSet = TreeRangeSet.create();
    for (Range<Integer> range : ranges) {
        rangeSet.add(range);/* w ww  .  j a  va  2 s. co m*/
    }
    if (includeComments) {
        if (kind != SnippetKind.COMPILATION_UNIT) {
            throw new IllegalArgumentException("comment formatting is only supported for compilation units");
        }
        return formatter.getFormatReplacements(source, ranges);
    }
    SnippetWrapper wrapper = snippetWrapper(kind, source, initialIndent);
    ranges = offsetRanges(ranges, wrapper.offset);

    String replacement = formatter.formatSource(wrapper.contents.toString(), ranges);
    replacement = replacement.substring(wrapper.offset,
            replacement.length() - (wrapper.contents.length() - wrapper.offset - source.length()));

    List<Replacement> replacements = toReplacements(source, replacement);
    List<Replacement> filtered = new ArrayList<>();
    for (Replacement r : replacements) {
        if (rangeSet.encloses(r.getReplaceRange())) {
            filtered.add(r);
        }
    }
    return filtered;
}

---