Example usage for com.google.common.collect Range isConnected

List of usage examples for com.google.common.collect Range isConnected

  1. HOME
  2. Java
  3. com.google.common
  4. com.google.common.collect.*
  5. Range
  6. isConnected

Introduction

In this page you can find the example usage for com.google.common.collect Range isConnected.

Prototype

public boolean isConnected(Range<C> other)

Source Link

Document

Returns true if there exists a (possibly empty) range which is #encloses enclosed by both this range and other .

Usage

From source file:org.brocalc.domain.RangeConstraintMapUtil.java

public static <T extends Comparable<?>> Map<Range<T>, BrokerageScheduleComponent> createRangeConstrainedMap(
        final String rangeName) {
    final Map<Range<T>, BrokerageScheduleComponent> baseMap = Maps.newHashMap();
    Map<Range<T>, BrokerageScheduleComponent> constrainedMap = MapConstraints.constrainedMap(baseMap,
            new MapConstraint<Range<T>, BrokerageScheduleComponent>() {

                @Override//from   w w  w . ja v  a  2 s  . co m
                public void checkKeyValue(Range<T> newKey,
                        BrokerageScheduleComponent brokerageScheduleComponent) {
                    baseMap.keySet();
                    for (Range<T> existingKey : baseMap.keySet()) {
                        if (existingKey.isConnected(newKey) && !existingKey.intersection(newKey).isEmpty()) {
                            throw new RangeOverlapException(
                                    rangeName + " " + newKey + " overlaps with " + existingKey);
                        }
                    }
                }
            });
    return constrainedMap;
}

From source file:org.pshdl.model.simulation.RangeTool.java

private static void validate(Set<Range<BigInteger>> split) {
    System.out.println("Result:" + split);
    Range<BigInteger> last = Range.closed(BigInteger.valueOf(-1), BigInteger.valueOf(-1));
    for (final Range<BigInteger> range : split) {
        if (range.isConnected(last))
            throw new IllegalArgumentException("Ranges are connected:" + last + " and " + range);
        last = range;/*from  w w w.  j a v a  2 s. co  m*/
    }
}

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

/**
 * Determines the effect of the given allele at the given position within a
 * transcript. Currently, this routine is relatively primitive: it only works
 * with SNPs and only computes effects on coding regions of the transcript.
 * This utility currently does not handle any splice sites well, including
 * splice site disruption and codons which span two exons.
 *
 * @param variantStart 0-based absolute start for the variant.
 * @param allele Bases to substitute at {@code variantStart}.
 * @param transcript The affected transcript.
 * @param transcriptBases The reference bases which span the provided
 *     {@code transcript}. Must match the exact length of the
 *     {@code transcript.position}./*from w ww.j av a  2s . c  om*/
 * @return The effect of this variant on the given transcript, or null if
 *     unknown.
 */
public static VariantEffect determineVariantTranscriptEffect(long variantStart, String allele,
        Annotation transcript, String transcriptBases) {
    long txLen = transcript.getEnd() - transcript.getStart();
    Preconditions.checkArgument(transcriptBases.length() == txLen,
            "transcriptBases must have equal length to the transcript; got " + transcriptBases.length()
                    + " and " + txLen + ", respectively");
    if (allele.length() != 1) {
        LOG.fine("determineVariantTranscriptEffects() only supports SNPs, ignoring " + allele);
        return null;
    }
    if (transcript.getTranscript().getCodingSequence() == null) {
        LOG.fine("determineVariantTranscriptEffects() only supports intersection with coding "
                + "transcript, ignoring ");
        return null;
    }

    long variantEnd = variantStart + 1;
    Range<Long> variantRange = Range.closedOpen(variantStart, variantEnd);
    Range<Long> codingRange = Range.closedOpen(transcript.getTranscript().getCodingSequence().getStart(),
            transcript.getTranscript().getCodingSequence().getEnd());
    if (Boolean.TRUE.equals(transcript.getReverseStrand())) {
        allele = SequenceUtil.reverseComplement(allele);
    }
    for (Exon exon : transcript.getTranscript().getExons()) {
        // For now, only compute effects on variants within the coding region of an exon.
        Range<Long> exonRange = Range.closedOpen(exon.getStart(), exon.getEnd());
        if (exonRange.isConnected(codingRange) && exonRange.intersection(codingRange).isConnected(variantRange)
                && !exonRange.intersection(codingRange).intersection(variantRange).isEmpty()) {
            // Get the bases which correspond to this exon.
            int txOffset = transcript.getStart().intValue();
            String exonBases = transcriptBases.substring(exon.getStart().intValue() - txOffset,
                    exon.getEnd().intValue() - txOffset);
            int variantExonOffset = (int) (variantStart - exon.getStart());

            if (Boolean.TRUE.equals(transcript.getReverseStrand())) {
                // Normalize the offset and bases to 5' -> 3'.
                exonBases = SequenceUtil.reverseComplement(exonBases);
                variantExonOffset = (int) (exon.getEnd() - variantEnd);
            }

            // Determine the indices for the codon which contains this variant.
            if (exon.getFrame() == null) {
                LOG.fine("exon lacks frame data, cannot determine effect");
                return null;
            }
            int offsetWithinCodon = (variantExonOffset + exon.getFrame()) % 3;
            int codonExonOffset = variantExonOffset - offsetWithinCodon;
            if (codonExonOffset < 0 || exonBases.length() <= codonExonOffset + 3) {
                LOG.fine("variant codon spans multiple exons, this case is not yet handled");
                return null;
            }
            String fromCodon = exonBases.substring(codonExonOffset, codonExonOffset + 3);
            String toCodon = fromCodon.substring(0, offsetWithinCodon) + allele
                    + fromCodon.substring(offsetWithinCodon + 1);
            return codonChangeToEffect(fromCodon, toCodon);
        }
    }
    return null;
}

From source file:org.nmdp.ngs.range.Ranges.java

/**
 * Return true if the specified ranges intersect.
 *
 * @param <C> range endpoint type//w  w w  .  j a v  a2  s.co  m
 * @param range0 first range, must not be null
 * @param range1 second range, must not be null
 * @return true if the specified ranges intersect
 */
public static <C extends Comparable> boolean intersect(final Range<C> range0, final Range<C> range1) {
    checkNotNull(range0);
    checkNotNull(range1);
    return range0.isConnected(range1) && !range0.intersection(range1).isEmpty();
}

From source file:org.cinchapi.concourse.server.model.Ranges.java

/**
 * Return a new {@link Range} that is the merger (e.g. union) of {@code a}
 * and {@code b}. The new {@link Range} maintains both the lower and higher
 * endpoint/bound between the two inputs.
 * // www  .  j  a va 2 s  .c om
 * @param a
 * @param b
 * @return the union of {@code a} and {@code b}
 */
public static Range<Value> merge(Range<Value> a, Range<Value> b) {
    if (a.isConnected(b)) {
        boolean aStart = compareToLower(a, b) < 0;
        boolean aEnd = compareToUpper(a, b) > 0;
        boolean lower = getLowerBoundType(aStart ? a : b) == BoundType.CLOSED;
        boolean upper = getUpperBoundType(aStart ? a : b) == BoundType.CLOSED;
        if (lower && upper) {
            return Range.closed(getLowerEndpoint(aStart ? a : b), getUpperEndpoint(aEnd ? a : b));
        } else if (!lower && upper) {
            return Range.closedOpen(getLowerEndpoint(aStart ? a : b), getUpperEndpoint(aEnd ? a : b));
        } else if (lower && !upper) {
            return Range.openClosed(getLowerEndpoint(aStart ? a : b), getUpperEndpoint(aEnd ? a : b));
        } else {
            return Range.open(getLowerEndpoint(aStart ? a : b), getUpperEndpoint(aEnd ? a : b));
        }
    } else {
        return null;
    }
}

From source file:org.apache.kylin.storage.cache.TsConditionExtractor.java

private static Range<Long> extractTsConditionInternal(TupleFilter filter, TblColRef colRef) {
    if (filter == null) {
        return Range.all();
    }//from   www .j a v a  2  s .  c  om

    if (filter instanceof LogicalTupleFilter) {
        if (filter.getOperator() == TupleFilter.FilterOperatorEnum.AND) {
            Range<Long> ret = Range.all();
            for (TupleFilter child : filter.getChildren()) {
                Range childRange = extractTsConditionInternal(child, colRef);
                if (childRange != null) {
                    if (ret.isConnected(childRange) && !ret.intersection(childRange).isEmpty()) {
                        ret = ret.intersection(childRange);
                    } else {
                        return null;
                    }
                } else {
                    return null;
                }
            }
            return ret.isEmpty() ? null : ret;
        } else {
            //for conditions like date > DATE'2000-11-11' OR date < DATE '1999-01-01'
            //we will use Ranges.all() rather than two ranges to represent them
            return Range.all();
        }
    }

    if (filter instanceof CompareTupleFilter) {
        CompareTupleFilter compareTupleFilter = (CompareTupleFilter) filter;
        if (compareTupleFilter.getColumn() == null)// column will be null at filters like " 1<>1"
            return Range.all();

        if (compareTupleFilter.getColumn().equals(colRef)) {
            Object firstValue = compareTupleFilter.getFirstValue();
            long t;
            switch (compareTupleFilter.getOperator()) {
            case EQ:
                t = DateFormat.stringToMillis((String) firstValue);
                return Range.closed(t, t);
            case LT:
                t = DateFormat.stringToMillis((String) firstValue);
                return Range.lessThan(t);
            case LTE:
                t = DateFormat.stringToMillis((String) firstValue);
                return Range.atMost(t);
            case GT:
                t = DateFormat.stringToMillis((String) firstValue);
                return Range.greaterThan(t);
            case GTE:
                t = DateFormat.stringToMillis((String) firstValue);
                return Range.atLeast(t);
            case NEQ:
            case IN://not handled for now
                break;
            default:
            }
        }
    }
    return Range.all();
}

From source file:org.apache.calcite.adapter.druid.DruidDateTimeUtils.java

protected static List<Range<Calendar>> extractRanges(RexNode node, boolean withNot) {
    switch (node.getKind()) {
    case EQUALS:/*  www.j  av a 2 s .  co m*/
    case LESS_THAN:
    case LESS_THAN_OR_EQUAL:
    case GREATER_THAN:
    case GREATER_THAN_OR_EQUAL:
    case BETWEEN:
    case IN:
        return leafToRanges((RexCall) node, withNot);

    case NOT:
        return extractRanges(((RexCall) node).getOperands().get(0), !withNot);

    case OR: {
        RexCall call = (RexCall) node;
        List<Range<Calendar>> intervals = Lists.newArrayList();
        for (RexNode child : call.getOperands()) {
            List<Range<Calendar>> extracted = extractRanges(child, withNot);
            if (extracted != null) {
                intervals.addAll(extracted);
            }
        }
        return intervals;
    }

    case AND: {
        RexCall call = (RexCall) node;
        List<Range<Calendar>> ranges = new ArrayList<>();
        for (RexNode child : call.getOperands()) {
            List<Range<Calendar>> extractedRanges = extractRanges(child, false);
            if (extractedRanges == null || extractedRanges.isEmpty()) {
                // We could not extract, we bail out
                return null;
            }
            if (ranges.isEmpty()) {
                ranges.addAll(extractedRanges);
                continue;
            }
            List<Range<Calendar>> overlapped = new ArrayList<>();
            for (Range current : ranges) {
                for (Range interval : extractedRanges) {
                    if (current.isConnected(interval)) {
                        overlapped.add(current.intersection(interval));
                    }
                }
            }
            ranges = overlapped;
        }
        return ranges;
    }

    default:
        return null;
    }
}

From source file:net.bican.iplib.IPAddresses.java

private static Set<Range<IPAddress>> findOneConnected(final Set<Range<IPAddress>> intervals) {
    Range<IPAddress> f1 = null;//from  w w w  .ja v  a2  s.com
    Range<IPAddress> f2 = null;
    for (final Range<IPAddress> s : intervals) {
        for (final Range<IPAddress> s2 : intervals) {
            final Range<IPAddress> sc = IPAddresses.canonical(s, s.lowerEndpoint().getDomain());
            final Range<IPAddress> sc2 = IPAddresses.canonical(s, s2.lowerEndpoint().getDomain());
            if ((sc.equals(sc2)) || (s.isConnected(s2))) {
                f1 = s;
                f2 = s2;
                break;
            }
        }
        if (f1 != null) {
            break;
        }
    }
    if (f1 != null) {
        final Set<Range<IPAddress>> newIntervals = new TreeSet<>(IPAddressRangeComparator.getComparator());
        newIntervals.addAll(intervals);
        final Range<IPAddress> f = f1.span(f2);
        newIntervals.remove(f1);
        newIntervals.remove(f2);
        newIntervals.add(f);
        return newIntervals;
    }
    return intervals;
}

From source file:org.apache.hadoop.hive.ql.optimizer.calcite.druid.DruidIntervalUtils.java

/**
 * Given a list of predicates, it generates the equivalent Interval
 * (if possible). It assumes that all the predicates in the input
 * reference a single column : the timestamp column.
 * // w  ww . ja  v a2s  . c  o  m
 * @param conjs list of conditions to use for the transformation
 * @return interval representing the conditions in the input list
 */
public static List<Interval> createInterval(RelDataType type, List<RexNode> conjs) {
    List<Range> ranges = new ArrayList<>();
    for (RexNode child : conjs) {
        List<Range> extractedRanges = extractRanges(type, child, false);
        if (extractedRanges == null || extractedRanges.isEmpty()) {
            // We could not extract, we bail out
            return null;
        }
        if (ranges.isEmpty()) {
            ranges.addAll(extractedRanges);
            continue;
        }
        List<Range> overlapped = Lists.newArrayList();
        for (Range current : ranges) {
            for (Range interval : extractedRanges) {
                if (current.isConnected(interval)) {
                    overlapped.add(current.intersection(interval));
                }
            }
        }
        ranges = overlapped;
    }
    List<Range> compactRanges = condenseRanges(ranges);
    LOG.debug("Inferred ranges on interval : " + compactRanges);
    return toInterval(compactRanges);
}

From source file:org.apache.kylin.common.util.RangeUtil.java

/**
 * remove from self the elements that exist in other
 * @return//from   w ww . j  ava2  s.c o  m
 */
public static <C extends Comparable<?>> List<Range<C>> remove(Range<C> self, Range<C> other) {

    // mimic the following logic in guava 18:
    //        RangeSet<C> rangeSet = TreeRangeSet.create();
    //        rangeSet.add(self);
    //        rangeSet.remove(other);
    //        return Lists.newArrayList(rangeSet.asRanges());

    if (other == null || !self.isConnected(other)) {
        return Collections.singletonList(self);
    }

    Range<C> share = self.intersection(other);
    if (share.isEmpty()) {
        return Collections.singletonList(self);
    }

    List<Range<C>> ret = Lists.newArrayList();

    //see left part
    if (!self.hasLowerBound()) {
        if (share.hasLowerBound()) {
            if (share.lowerBoundType() == BoundType.CLOSED) {
                ret.add(Range.lessThan(share.lowerEndpoint()));
            } else {
                ret.add(Range.atMost(share.lowerEndpoint()));
            }
        }
    } else {
        if (self.lowerEndpoint() != share.lowerEndpoint()) {
            if (self.lowerBoundType() == BoundType.CLOSED) {
                if (share.lowerBoundType() == BoundType.CLOSED) {
                    ret.add(Range.closedOpen(self.lowerEndpoint(), share.lowerEndpoint()));
                } else {
                    ret.add(Range.closed(self.lowerEndpoint(), share.lowerEndpoint()));
                }
            } else {
                if (share.lowerBoundType() == BoundType.CLOSED) {
                    ret.add(Range.open(self.lowerEndpoint(), share.lowerEndpoint()));
                } else {
                    ret.add(Range.openClosed(self.lowerEndpoint(), share.lowerEndpoint()));
                }
            }
        } else {
            if (self.lowerBoundType() == BoundType.CLOSED && share.lowerBoundType() == BoundType.OPEN) {
                ret.add(Range.closed(self.lowerEndpoint(), share.lowerEndpoint()));
            }
        }
    }

    //see right part 
    if (!self.hasUpperBound()) {
        if (share.hasUpperBound()) {
            if (share.upperBoundType() == BoundType.CLOSED) {
                ret.add(Range.greaterThan(share.upperEndpoint()));
            } else {
                ret.add(Range.atLeast(share.upperEndpoint()));
            }
        }
    } else {
        if (self.upperEndpoint() != share.upperEndpoint()) {
            if (self.upperBoundType() == BoundType.CLOSED) {
                if (share.upperBoundType() == BoundType.CLOSED) {
                    ret.add(Range.openClosed(share.upperEndpoint(), self.upperEndpoint()));
                } else {
                    ret.add(Range.closed(share.upperEndpoint(), self.upperEndpoint()));
                }
            } else {
                if (share.upperBoundType() == BoundType.CLOSED) {
                    ret.add(Range.open(share.upperEndpoint(), self.upperEndpoint()));
                } else {
                    ret.add(Range.closedOpen(share.upperEndpoint(), self.upperEndpoint()));
                }
            }
        } else {
            if (self.upperBoundType() == BoundType.CLOSED && share.upperBoundType() == BoundType.OPEN) {
                ret.add(Range.closed(self.upperEndpoint(), share.upperEndpoint()));
            }
        }
    }

    return ret;

}