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

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

Introduction

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

Prototype

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

Source Link

Document

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

Usage

From source file:io.blobkeeper.index.service.IndexServiceImpl.java

@NotNull
@Override/*from www.  j  a  v  a2s .  co  m*/
public Range<Long> getMinMaxRange(@NotNull Partition partition) {
    List<IndexElt> elts = getListByPartition(partition);

    MinMaxConsumer minMax = elts.stream().collect(MinMaxConsumer::new, MinMaxConsumer::accept,
            MinMaxConsumer::combine);

    if (minMax.isEmpty()) {
        throw new NoIndexRangeException();
    } else {
        return Range.openClosed(minMax.getMin().getId() - 1, minMax.getMax().getId());
    }
}

From source file:com.wealdtech.jackson.modules.DateTimeRangeDeserializer.java

public static Range<DateTime> deserialize(final String txt) throws IOException {
      final int txtLen = txt.length();

      final int firstDateChar;
      boolean lowerClosed;
      if (txt.charAt(0) == '[') {
          firstDateChar = 1;/*from  w  w  w.  j  ava  2  s  . c o m*/
          lowerClosed = true;
      } else if (txt.charAt(0) == '(') {
          firstDateChar = 1;
          lowerClosed = false;
      } else if (txt.charAt(0) >= '0' && txt.charAt(0) <= '9') {
          // Lazy version
          firstDateChar = 0;
          lowerClosed = true;
      } else {
          throw new DataError.Bad("Unexpected first character in range \"" + txt + "\"");
      }

      boolean upperClosed;
      if (txt.charAt(txtLen - 1) == ']') {
          upperClosed = true;
      } else if (txt.charAt(txtLen - 1) == ')') {
          upperClosed = false;
      } else if (firstDateChar == 0) {
          upperClosed = false;
      } else {
          throw new DataError.Bad("Unexpected last character in range \"" + txt + "\"");
      }

      final Iterator<String> dateTimes;
      if (txt.indexOf(WEALD_SPLITTER_CHAR) != -1) {
          dateTimes = WEALD_SPLITTER.split(txt.substring(firstDateChar, txtLen - firstDateChar)).iterator();
      } else if (txt.indexOf(GUAVA_SPLITTER_CHAR) != -1) {
          dateTimes = GUAVA_SPLITTER.split(txt.substring(firstDateChar, txtLen - firstDateChar)).iterator();
      } else {
          throw new DataError.Bad("Cannot find a range separator in range \"" + txt + "\"");
      }
      String start = dateTimes.next();
      String end = dateTimes.next();

      boolean lowerBound;
      final DateTime lowerPoint;
      if (start.equals(NEGATIVE_INFINITY)) {
          lowerBound = false;
          lowerPoint = null;
      } else {
          lowerBound = true;
          lowerPoint = DateTimeDeserializer.deserialize(start);
      }

      boolean upperBound;
      final DateTime upperPoint;
      if (end.equals(POSITIVE_INFINITY)) {
          upperBound = false;
          upperPoint = null;
      } else {
          upperBound = true;
          upperPoint = DateTimeDeserializer.deserialize(end);
      }

      if (lowerBound == false && upperBound == false) {
          return Range.all();
      } else if (lowerBound == false) {
          // Upper present
          if (upperClosed == true) {
              return Range.lessThan(upperPoint);
          } else {
              return Range.atMost(upperPoint);
          }
      } else if (upperBound == false) {
          // Lower present
          if (lowerClosed == true) {
              return Range.atLeast(lowerPoint);
          } else {
              return Range.greaterThan(lowerPoint);
          }
      } else {
          // Both present
          if (lowerClosed == true) {
              if (upperClosed == true) {
                  return Range.closed(lowerPoint, upperPoint);
              } else {
                  return Range.closedOpen(lowerPoint, upperPoint);
              }
          } else {
              if (upperClosed == true) {
                  return Range.openClosed(lowerPoint, upperPoint);
              } else {
                  return Range.open(lowerPoint, upperPoint);
              }
          }
      }
  }

From source file:com.google.android.apps.forscience.whistlepunk.audiogen.AudioPlaybackController.java

public void startPlayback(ChartController chartController, final DataController dataController,
        long firstTimestamp, long lastTimestamp, long xMinToLoad, final String sensorId) {
    if (!chartController.hasDrawnChart() || mPlaybackStatus != PLAYBACK_STATUS_NOT_PLAYING) {
        return;//from   w ww . jav a2  s .  c o  m
    }

    final double yMin = chartController.getRenderedYMin();
    final double yMax = chartController.getRenderedYMax();
    final long xMax = lastTimestamp;
    final List<ChartData.DataPoint> audioData = new ArrayList<>();

    if (xMinToLoad == RunReviewOverlay.NO_TIMESTAMP_SELECTED) {
        xMinToLoad = firstTimestamp;
    } else {
        if ((xMax - xMinToLoad) < .05 * (xMax - firstTimestamp)) {
            // If we are 95% or more towards the end, start at the beginning.
            // This allows for some slop.
            xMinToLoad = firstTimestamp;
        }
    }
    long xMaxToLoad = Math.min(xMinToLoad + DURATION_MS_PER_AUDIO_PLAYBACK_LOAD, xMax);
    final boolean fullyLoaded = xMaxToLoad == xMax;

    mHandler = new Handler();
    mPlaybackRunnable = new Runnable() {
        boolean mFullyLoaded = fullyLoaded;

        @Override
        public void run() {
            if (audioData.size() == 0) {
                stopPlayback();
                return;
            }

            // Every time we play a data point, we remove it from the list.
            ChartData.DataPoint point = audioData.remove(0);
            long timestamp = point.getX();

            // Load more data when needed, i.e. when we are within a given duration away from
            // the last loaded timestamp, and we aren't fully loaded yet.
            long lastTimestamp = audioData.size() == 0 ? timestamp : audioData.get(audioData.size() - 1).getX();
            if (timestamp + DURATION_MS_PER_AUDIO_PLAYBACK_LOAD / 2 > lastTimestamp && !mFullyLoaded) {
                long xMaxToLoad = Math.min(lastTimestamp + DURATION_MS_PER_AUDIO_PLAYBACK_LOAD, xMax);
                mFullyLoaded = xMaxToLoad == xMax;
                dataController.getScalarReadings(sensorId, /* tier 0 */ 0,
                        TimeRange.oldest(Range.openClosed(lastTimestamp, xMaxToLoad)),
                        DATAPOINTS_PER_AUDIO_PLAYBACK_LOAD, new MaybeConsumer<ScalarReadingList>() {
                            @Override
                            public void success(ScalarReadingList list) {
                                audioData.addAll(list.asDataPoints());
                            }

                            @Override
                            public void fail(Exception e) {
                                Log.e(TAG, "Error loading audio playback data");
                                stopPlayback();
                            }
                        });
            }

            // Now play the tone, and get set up for the next callback, if one is needed.
            try {
                mAudioGenerator.addData(timestamp, point.getY(), yMin, yMax);
                mAudioPlaybackListener.onTimestampUpdated(timestamp);
            } finally {
                // If this is the second to last point, some special handling
                // needs to be done to determine when to make the last tone.
                if (audioData.size() > 0) {
                    // Play the next note after the time between this point and the
                    // next point has elapsed.
                    // mPlaybackIndex is now the index of the next point.
                    mHandler.postDelayed(mPlaybackRunnable, audioData.get(0).getX() - timestamp);
                } else {
                    // The last note gets some duration.
                    mHandler.postDelayed(mPlaybackRunnable, LAST_TONE_DURATION_MS);
                }
            }
        }
    };

    // Load the first set of scalar readings, and start playing as soon as they are loaded.
    dataController.getScalarReadings(sensorId, /* tier 0 */ 0,
            TimeRange.oldest(Range.closed(xMinToLoad, xMaxToLoad)), DATAPOINTS_PER_AUDIO_PLAYBACK_LOAD,
            new MaybeConsumer<ScalarReadingList>() {
                @Override
                public void success(ScalarReadingList list) {
                    audioData.addAll(list.asDataPoints());
                    mAudioGenerator.startPlaying();
                    mPlaybackRunnable.run();
                    mPlaybackStatus = PLAYBACK_STATUS_PLAYING;
                    mAudioPlaybackListener.onAudioPlaybackStarted();
                }

                @Override
                public void fail(Exception e) {
                    if (Log.isLoggable(TAG, Log.ERROR)) {
                        Log.e(TAG, "Error loading audio playback data");
                        stopPlayback();
                    }
                }
            });

    mPlaybackStatus = PLAYBACK_STATUS_LOADING;
}

From source file:com.palantir.atlasdb.keyvalue.cassandra.TokenAwareMapper.java

public void refresh() {
    List<TokenRange> tokenRanges = getTokenRanges();

    ImmutableRangeMap.Builder<Token, List<InetAddress>> newTokenRing = ImmutableRangeMap.builder();
    for (TokenRange tokenRange : tokenRanges) {
        List<InetAddress> hosts = Lists.transform(tokenRange.getEndpoints(),
                new Function<String, InetAddress>() {
                    @Override//from   w  ww  . ja  v a2s .  c  o  m
                    public InetAddress apply(String endpoint) {
                        try {
                            return InetAddress.getByName(endpoint);
                        } catch (UnknownHostException e) {
                            throw new RuntimeException(e);
                        }
                    }
                });
        Token startToken = new Token(BaseEncoding.base16().decode(tokenRange.getStart_token().toUpperCase()));
        Token endToken = new Token(BaseEncoding.base16().decode(tokenRange.getEnd_token().toUpperCase()));
        if (startToken.compareTo(endToken) <= 0) {
            newTokenRing.put(Range.openClosed(startToken, endToken), hosts);
        } else {
            // Handle wrap-around
            newTokenRing.put(Range.greaterThan(startToken), hosts);
            newTokenRing.put(Range.atMost(endToken), hosts);
        }
    }
    tokenRing.set(newTokenRing.build());
}

From source file:com.google.android.apps.forscience.whistlepunk.GraphPopulator.java

private TimeRange computeRequestRange(NextRequestType type, long minTime, long maxTime) {
    switch (type) {
    case NONE://  www  .  j a  v a2 s .  c  om
        return null;
    case FIRST:
        return TimeRange.oldest(Range.closed(minTime, maxTime));
    case NEXT_LOWER:
        return TimeRange.oldest(Range.closedOpen(minTime, mRequestedTimes.lowerEndpoint()));
    case NEXT_HIGHER:
        return TimeRange.oldest(Range.openClosed(mRequestedTimes.upperEndpoint(), maxTime));
    default:
        throw new IllegalStateException("Should never happen");
    }
}

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.
 * /*from   w  w  w  .  ja  v  a  2  s  .c o m*/
 * @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:com.facebook.presto.rcfile.AbstractTestRcFileReader.java

private static ContiguousSet<Long> longsBetween(long lowerInclusive, long upperExclusive) {
    return ContiguousSet.create(Range.openClosed(lowerInclusive, upperExclusive), DiscreteDomain.longs());
}

From source file:com.facebook.presto.rcfile.AbstractTestRcFileReader.java

private static ContiguousSet<Integer> intsBetween(int lowerInclusive, int upperExclusive) {
    return ContiguousSet.create(Range.openClosed(lowerInclusive, upperExclusive), DiscreteDomain.integers());
}

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 ww w  . j  a va2s  . 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;
}

From source file:org.apache.bookkeeper.mledger.impl.ReadOnlyManagedLedgerImpl.java

@Override
public long getNumberOfEntries() {
    return getNumberOfEntries(Range.openClosed(PositionImpl.earliest, getLastPosition()));
}