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

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

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

Introduction

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

Prototype

public static <C extends Comparable<?>> Range<C> closed(C lower, C upper)

Source Link

Document

Returns a range that contains all values greater than or equal to lower and less than or equal to upper .

Usage

From source file:org.robotframework.ide.eclipse.main.plugin.tableeditor.source.SuiteSourceQuickAssistProcessor.java

private boolean isInvokedWithinAnnotationPosition(final IQuickAssistInvocationContext invocationContext,
        final Position annotationPosition) {
    return annotationPosition != null && Range
            .closed(annotationPosition.getOffset(),
                    annotationPosition.getOffset() + annotationPosition.getLength())
            .contains(invocationContext.getOffset());
}

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

public static <C extends Comparable<C>> Range<C> createRange(C lower, C upper) {
    if (lower.compareTo(upper) > 0)
        return Range.closed(upper, lower);
    return Range.closed(lower, upper);
}

From source file:org.opendaylight.lispflowmapping.type.lisp.LocatorRecord.java

public LocatorRecord setPriority(short priority) {
    if (priority != 0) {
        boolean isValidRange = false;
        List<Range<Short>> rangeConstraints = new ArrayList<>();
        rangeConstraints.add(Range.closed(new Short("0"), new Short("255")));
        for (Range<Short> r : rangeConstraints) {
            if (r.contains(priority)) {
                isValidRange = true;//from   w  ww  .  ja  v a  2 s. co  m
            }
        }
        if (!isValidRange) {
            throw new IllegalArgumentException(
                    String.format("Invalid range: %s, expected: %s.", priority, rangeConstraints));
        }
    }
    this.priority = priority;
    return this;
}

From source file:eu.numberfour.n4js.ui.editor.EditorContentExtractor.java

/**
 * Optionally returns with the semantic AST node element (given as the element URI) as a {@link StyledTextDescriptor
 * styled text descriptor}. If the element cannot be resolved or the styled text cannot be computed this method
 * returns with and {@link Optional#absent() absent} instance but never {@code null}.
 *
 * @param uri//from   ww w  .j a  v  a2s .  co  m
 *            the URI of the semantic element in the AST.
 * @return a styled text descriptor representing the extracted code for the semantic AST node given with its unique
 *         URI.
 */
public Optional<StyledTextDescriptor> getDescriptorForSemanticElement(final URI uri) {
    if (null == uri) {
        return absent();
    }

    final URI trimmedUri = uri.hasFragment() ? uri.trimFragment() : uri;
    final IN4JSProject project = core.findProject(trimmedUri).orNull();
    if (project == null) {
        return absent();
    }
    final ResourceSet resSet = core.createResourceSet(Optional.of(project));
    final IResourceDescriptions index = core.getXtextIndex(resSet);
    final IResourceDescription resDesc = index.getResourceDescription(trimmedUri);
    final TModule module = core.loadModuleFromIndex(resSet, resDesc, false);
    if (null == module || null == module.eResource() || null == module.eResource().getResourceSet()) {
        return absent();
    }

    final URI moduleUri = module.eResource().getURI();
    final IFile file = getWorkspace().getRoot().getFile(new Path(moduleUri.toPlatformString(true)));
    if (null == file || !file.exists()) {
        return absent();
    }

    final FileEditorInput editorInput = new FileEditorInput(file);
    try {
        docProvider.connect(editorInput);
    } catch (final CoreException e) {
        LOGGER.error("Error while connecting editor input with document provider: " + e);
        return absent();
    }

    final IDocument doc = docProvider.getDocument(editorInput);
    if (null == doc) {
        return absent();
    }

    final XtextResource xtextResource = (XtextResource) module.eResource();
    final ResourceSet resourceSet = xtextResource.getResourceSet();
    final EObject object = resourceSet.getEObject(uri, true);
    if (null == object) {
        return absent();
    }

    final ITextRegion textRegion = locationInFileProvider.getFullTextRegion(object);
    if (null == textRegion) {
        return absent();
    }

    try {

        final int lineOfOffset = doc.getLineOfOffset(textRegion.getOffset());
        final int lineOffset = doc.getLineOffset(lineOfOffset);
        final int offset = lineOffset;
        final int length = textRegion.getLength() + (textRegion.getOffset() - lineOffset);
        final String text = doc.get(offset, length);

        final IPresentationRepairer repairer = repairerProvider.get();
        final IPresentationDamager damager = damagerProvider.get();
        for (final String contentType : partitionTypeMapper.getSupportedPartitionTypes()) {
            reconciler.setRepairer(repairer, contentType);
            repairer.setDocument(doc);
            reconciler.setDamager(damager, contentType);
            damager.setDocument(doc);
        }

        final Region region = new Region(offset, length);
        final TextPresentation textPresentation = reconciler.createRepairDescription(region, doc);

        final Iterator<?> rangeItr = textPresentation.getAllStyleRangeIterator();
        final Collection<StyleRange> ranges = newLinkedList();
        while (rangeItr.hasNext()) {
            final Object next = rangeItr.next();
            if (next instanceof StyleRange) {
                ranges.add((StyleRange) next);
            }
        }

        final Range<Integer> textRange = Range.closed(offset, offset + length);
        for (final Iterator<StyleRange> itr = ranges.iterator(); itr.hasNext(); /* nothing */) {
            final StyleRange range = itr.next();
            if (!textRange.contains(range.start) || !textRange.contains(range.start + range.length)) {
                itr.remove();
            } else {
                range.start = range.start - offset;
            }
        }

        return fromNullable(new StyledTextDescriptorImpl(text, ranges));

    } catch (final BadLocationException e) {
        LOGGER.error("Error while trying to extract text from document.", e);
        return absent();
    }

}

From source file:org.caleydo.view.heatmap.v2.internal.DimensionRenderer.java

public Set<Integer> forLocation(GLLocation location, float textWidth) {
    if (spacing == null)
        return GLLocation.UNKNOWN_IDS;
    float offset = (float) location.getOffset();
    float offset2 = (float) location.getOffset2();
    if (label == EShowLabels.LEFT) {
        offset -= textWidth;/*w ww.  ja v  a2s  . c o  m*/
        offset2 -= textWidth;
    }
    int from = spacing.getIndex(offset);
    int to = spacing.getIndex(offset2);
    return ContiguousSet.create(Range.closed(from, to), DiscreteDomain.integers());
}

From source file:annis.visualizers.component.grid.EventExtractor.java

public static void removeEmptySpace(LinkedHashMap<String, ArrayList<Row>> rowsByAnnotation, Row tokenRow) {
    List<Range<Integer>> gaps = new LinkedList<>();

    BitSet totalOccupancyGrid = new BitSet();
    for (Map.Entry<String, ArrayList<Row>> layer : rowsByAnnotation.entrySet()) {
        for (Row r : layer.getValue()) {
            totalOccupancyGrid.or(r.getOccupancyGridCopy());
        }/*from   ww w .j a  v  a2 s.  com*/
    }
    // We always include the token row in the occupancy grid since it is not
    // a gap. Otherwise empty token would trigger gaps if the token list
    // is included in the visualizer output.
    // See https://github.com/korpling/ANNIS/issues/281 for the corresponding
    // bug report.
    if (tokenRow != null) {
        totalOccupancyGrid.or(tokenRow.getOccupancyGridCopy());
    }

    // The Range class can give us the next bit that is not set. Use this
    // to detect gaps. A gap starts from the next non-set bit and goes to
    // the next set bit.
    Range<Integer> gap = Range.closed(-1, totalOccupancyGrid.nextSetBit(0));
    while (true) {
        int gapStart = totalOccupancyGrid.nextClearBit(gap.upperEndpoint() + 1);
        int gapEnd = totalOccupancyGrid.nextSetBit(gapStart);
        if (gapEnd <= 0) {
            break;
        }
        gap = Range.closed(gapStart, gapEnd - 1);
        gaps.add(gap);

    }

    int gapID = 0;
    int totalOffset = 0;
    for (Range<Integer> gRaw : gaps) {
        // adjust the space range itself
        Range<Integer> g = Range.closed(gRaw.lowerEndpoint() - totalOffset, gRaw.upperEndpoint() - totalOffset);
        int offset = g.upperEndpoint() - g.lowerEndpoint();
        totalOffset += offset;

        for (Entry<String, ArrayList<Row>> rowEntry : rowsByAnnotation.entrySet()) {
            ArrayList<Row> rows = rowEntry.getValue();
            for (Row r : rows) {
                List<GridEvent> eventsCopy = new LinkedList<>(r.getEvents());
                for (GridEvent e : eventsCopy) {
                    if (e.getLeft() >= g.upperEndpoint()) {

                        r.removeEvent(e);
                        e.setLeft(e.getLeft() - offset);
                        e.setRight(e.getRight() - offset);
                        r.addEvent(e);
                    }
                }

                // add a special space event
                String spaceCaption = "";
                if ("tok".equalsIgnoreCase(rowEntry.getKey())) {
                    spaceCaption = "(...)";
                }
                GridEvent spaceEvent = new GridEvent("gap-" + gapID, g.lowerEndpoint(), g.lowerEndpoint(),
                        spaceCaption);
                spaceEvent.setSpace(true);
                r.addEvent(spaceEvent);
                gapID++;
            }
        }
    }
}

From source file:eu.interedition.collatex.medite.Matches.java

public SortedSet<SortedSet<VertexMatch.WithTokenIndex>> findMaximalUniqueMatches() {
    final List<SortedSet<VertexMatch.WithTokenIndex>> allMatches = Lists.newArrayList(this);
    final SortedSet<SortedSet<VertexMatch.WithTokenIndex>> maximalUniqueMatches = Sets
            .newTreeSet(VertexMatch.<VertexMatch.WithTokenIndex>setComparator());

    while (true) {
        SortedSet<VertexMatch.WithTokenIndex> nextMum = null;
        SortedSet<VertexMatch.WithTokenIndex> candidate = null;
        for (SortedSet<VertexMatch.WithTokenIndex> successor : allMatches) {
            if (candidate == null) {
                continue;
            }/*from   www  .ja  v  a  2s  .  c o  m*/
            if (candidate.size() > successor.size() || candidate.first().token == successor.first().token) {
                nextMum = candidate;
                break;
            }
            candidate = successor;
        }
        if (nextMum == null) {
            nextMum = Iterables.getFirst(allMatches, null);
        }
        if (nextMum == null) {
            break;
        }
        Preconditions.checkState(maximalUniqueMatches.add(nextMum), "Duplicate MUM");

        Iterables.removeIf(allMatches,
                VertexMatch.filter(
                        new IntegerRangeSet(
                                Range.closed(nextMum.first().vertexRank, nextMum.last().vertexRank)),
                        new IntegerRangeSet(Range.closed(nextMum.first().token, nextMum.last().token))));
    }
    return maximalUniqueMatches;
}

From source file:org.corpus_tools.graphannis.SaltExport.java

private static void recreateText(final String name, List<SNode> rootNodes, final SDocumentGraph g) {
    final StringBuilder text = new StringBuilder();
    final STextualDS ds = g.createTextualDS("");

    ds.setName(name);/*from   w  w  w  .  j av a  2s  .  co m*/

    Map<SToken, Range<Integer>> token2Range = new HashMap<>();

    // traverse the token chain using the order relations
    g.traverse(rootNodes, SGraph.GRAPH_TRAVERSE_TYPE.TOP_DOWN_DEPTH_FIRST, "ORDERING_" + name,
            new GraphTraverseHandler() {
                @Override
                public void nodeReached(SGraph.GRAPH_TRAVERSE_TYPE traversalType, String traversalId,
                        SNode currNode, SRelation<SNode, SNode> relation, SNode fromNode, long order) {
                    if (fromNode != null) {
                        text.append(" ");
                    }

                    SFeature featTok = currNode.getFeature("annis::tok");
                    if (featTok != null && currNode instanceof SToken) {
                        int idxStart = text.length();
                        text.append(featTok.getValue_STEXT());
                        token2Range.put((SToken) currNode, Range.closed(idxStart, text.length()));
                    }
                }

                @Override
                public void nodeLeft(SGraph.GRAPH_TRAVERSE_TYPE traversalType, String traversalId,
                        SNode currNode, SRelation<SNode, SNode> relation, SNode fromNode, long order) {
                }

                @Override
                public boolean checkConstraint(SGraph.GRAPH_TRAVERSE_TYPE traversalType, String traversalId,
                        SRelation relation, SNode currNode, long order) {
                    if (relation == null) {
                        // TODO: check if this is ever true
                        return true;
                    } else if (relation instanceof SOrderRelation && Objects.equal(name, relation.getType())) {
                        return true;
                    } else {
                        return false;
                    }
                }
            });

    // update the actual text
    ds.setText(text.toString());

    // add all relations

    token2Range.forEach((t, r) -> {
        STextualRelation rel = SaltFactory.createSTextualRelation();
        rel.setSource(t);
        rel.setTarget(ds);
        rel.setStart(r.lowerEndpoint());
        rel.setEnd(r.upperEndpoint());
        g.addRelation(rel);
    });
}

From source file:com.github.drbookings.ui.controller.EarningsViewController.java

private void doChart(Collection<? extends BookingEntry> allElements) {
    if (logger.isDebugEnabled()) {
        logger.debug("Doing chart");
    }//w  w  w.j  a  v a2s  .  c  o m

    netProfitTotal.getData().clear();
    //        netEarningsBooking.getData().clear();
    //        netEarningsAirbnb.getData().clear();
    netEarningsTotal.getData().clear();
    cleaningCosts.getData().clear();
    longTermEarnings.getData().clear();

    final float additionalCosts = SettingsManager.getInstance().getAdditionalCosts();
    final float numberOfRooms = SettingsManager.getInstance().getNumberOfRooms();
    final float totalAdditionalCosts = additionalCosts * numberOfRooms;

    BookingEntryMonthBins bin = new BookingEntryMonthBins(allElements);

    List<Double> numbers = new ArrayList<>();

    for (BookingEntryBin<YearMonth> be : bin.getBins()) {

        final Collection<? extends BookingEntry> bookingsFilteredByPaymentDate = be.getEntries().stream()
                .filter(new PaymentDateFilter(
                        Range.closed(be.getLabel().atDay(1), be.getLabel().atEndOfMonth())))
                .collect(Collectors.toList());

        Collection<? extends BookingEntry> longTermBookings = bookingsFilteredByPaymentDate.stream()
                .filter(b -> b.getElement().getNumberOfNights() > 7).collect(Collectors.toList());

        final Collection<? extends BookingEntry> bookingsFilteredByCleaningDate = be.getEntries().stream()
                .filter(new CleaningDateFilter(
                        Range.closed(be.getLabel().atDay(1), be.getLabel().atEndOfMonth())))
                .collect(Collectors.toList());

        double totalEarnings = BookingEntries.getNetEarnings(bookingsFilteredByPaymentDate);

        if (totalEarnings < 1) {
            continue;
        }

        double totalEarningsLongTerm = BookingEntries.getNetEarnings(longTermBookings);
        //            double earningsBooking = BookingEntries.getNetEarningsBooking(bookingsFilteredByPaymentDate);
        //            double earningsAirbnb = BookingEntries.getNetEarningsAirbnb(bookingsFilteredByPaymentDate);
        double cleaningCosts = BookingEntries.getCleaningCosts(bookingsFilteredByCleaningDate);
        double totalNetProfit = totalEarnings - totalAdditionalCosts - cleaningCosts;

        numbers.add(totalNetProfit);

        XYChart.Data<String, Number> data = new XYChart.Data<>(be.getLabel().toString(), totalNetProfit);
        data.setNode(new HoveredThresholdNode(totalNetProfit));
        netProfitTotal.getData().add(data);

        //            applyYValueToolTip(data);
        //            applyNodeSize(data);

        data = new XYChart.Data<>(be.getLabel().toString(), cleaningCosts);
        data.setNode(new HoveredThresholdNode(cleaningCosts));
        this.cleaningCosts.getData().add(data);

        data = new XYChart.Data<>(be.getLabel().toString(), totalEarnings);
        data.setNode(new HoveredThresholdNode(totalEarnings));
        this.netEarningsTotal.getData().add(data);

        data = new XYChart.Data<>(be.getLabel().toString(), totalEarningsLongTerm);
        data.setNode(new HoveredThresholdNode(totalEarningsLongTerm));
        this.longTermEarnings.getData().add(data);

    }

    labelMax.setText(String.format("%.2f", numbers.stream().mapToDouble(n -> n).max().orElse(0f)));
    labelMin.setText(String.format("%.2f", numbers.stream().mapToDouble(n -> n).min().orElse(0f)));
    labelAverage.setText(String.format("%.2f", numbers.stream().mapToDouble(n -> n).average().orElse(0f)));
}

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

/**
 * Return the ranges that include the points that are in {@code a} or the
 * {@code b} one and not in their intersection. The return set will include
 * between 0 and 2 ranges that together include all the points that meet
 * this criteria./*from   w  w  w.ja  v  a2s .c  o  m*/
 * <p>
 * <strong>NOTE:</strong> If the two ranges do not intersect, then a
 * collection containing both of them is returned (since they already form
 * their xor).
 * </p>
 * 
 * @param a
 * @param b
 * @return the set or ranges that make uValue the symmetric difference
 *         between this range and the {@code other} one
 */
public static Iterable<Range<Value>> xor(Range<Value> a, Range<Value> b) {
    List<Range<Value>> ranges = Lists.newArrayList();
    try {
        Range<Value> intersection = a.intersection(b);
        boolean aStart = compareToLower(a, b) < 0;
        boolean aEnd = compareToUpper(a, b) > 0;
        boolean lower = getLowerBoundType(aStart ? a : b) == BoundType.CLOSED;
        boolean upper = getUpperBoundType(aEnd ? a : b) == BoundType.CLOSED;
        boolean interLower = getLowerBoundType(intersection) == BoundType.OPEN;
        boolean interUpper = getUpperBoundType(intersection) == BoundType.OPEN;
        Range<Value> first;
        if (lower && interLower) {
            first = Range.closed(getLowerEndpoint(aStart ? a : b), getLowerEndpoint(intersection));
        } else if (!lower && interLower) {
            first = Range.openClosed(getLowerEndpoint(aStart ? a : b), getLowerEndpoint(intersection));
        } else if (lower && !interLower) {
            first = Range.closedOpen(getLowerEndpoint(aStart ? a : b), getLowerEndpoint(intersection));
        } else {
            first = Range.open(getLowerEndpoint(aStart ? a : b), getLowerEndpoint(intersection));
        }
        Range<Value> second;
        if (interUpper && upper) {
            second = Range.closed(getUpperEndpoint(intersection), getUpperEndpoint(aEnd ? a : b));
        } else if (!interUpper && upper) {
            second = Range.openClosed(getUpperEndpoint(intersection), getUpperEndpoint(aEnd ? a : b));
        } else if (interUpper && !interUpper) {
            second = Range.closedOpen(getUpperEndpoint(intersection), getUpperEndpoint(aEnd ? a : b));
        } else {
            second = Range.open(getUpperEndpoint(intersection), getUpperEndpoint(aEnd ? a : b));
        }
        if (!first.isEmpty()) {
            ranges.add(first);
        }
        if (!second.isEmpty()) {
            ranges.add(second);
        }
    } catch (IllegalArgumentException e) { // ranges dont intersect
        ranges.add(a);
        ranges.add(b);
    }
    return ranges;
}