@Test public void formattedStringShouldUseImapRangeNotationForSingleton() { assertThat(new UidRange(_2).getFormattedString()).isEqualTo("2"); }
public static List<UidRange> mergeRanges(List<UidRange> ranges) { if (ranges.isEmpty()) { return ranges; } RangeSet<MessageUid> rangeSet = createSortedRangeSet(ranges); List<Range<MessageUid>> mergedRanges = mergeContiguousRanges(rangeSet); return toUidRanges(mergedRanges); }
private static LinkedList<Range<MessageUid>> mergeContiguousRanges(RangeSet<MessageUid> rangeSet) { LinkedList<Range<MessageUid>> mergedRanges = new LinkedList<>(); for (Range<MessageUid> range: rangeSet.asRanges()) { Range<MessageUid> previous = mergedRanges.peekLast(); if (rangesShouldBeMerged(range, previous)) { replaceLastRange(mergedRanges, mergeRanges(range, previous)); } else { mergedRanges.add(range); } } return mergedRanges; }
private static RangeSet<MessageUid> createSortedRangeSet(List<UidRange> ranges) { RangeSet<MessageUid> rangeSet = TreeRangeSet.create(); for (UidRange range: ranges) { rangeSet.add(Range.closed(range.getLowVal(), range.getHighVal())); } return rangeSet; }
private static LinkedList<UidRange> toUidRanges(List<Range<MessageUid>> mergedRanges) { return mergedRanges.stream() .map(range -> new UidRange(range.lowerEndpoint(), range.upperEndpoint())) .collect(Collectors.toCollection(LinkedList::new)); }
if (!uidNext.isFirst()) { uidSet = new UidRange[] {new UidRange(MessageUid.MIN_VALUE, uidNext.previous())}; if (r.getLowVal().compareTo(firstUid) < 0) { if (r.getHighVal().compareTo(firstUid) > 0) { filteredUidSet.add(new UidRange(firstUid, r.getHighVal())); MessageRange messageSet = range.toMessageRange(); if (messageSet != null) { MessageRange normalizedMessageSet = normalizeMessageRange(session.getSelected(), messageSet);
@Test public void toMessageRangeShouldContainSameValues() { assertThat(new UidRange(_1, _4).toMessageRange()).isEqualTo(MessageRange.range(_1, _4)); }
private static String formatRanges(UidRange[] ranges) { if (ranges == null || ranges.length == 0) { return "*"; } StringBuilder rangeBuilder = new StringBuilder(); for (int i = 0; i < ranges.length; i++) { rangeBuilder.append(ranges[i].getFormattedString()); if (i + 1 < ranges.length) { rangeBuilder.append(","); } } return rangeBuilder.toString(); }
/** * Reads a "message set" argument, and parses into an IdSet. This also support the use of $ as sequence-set as stated in SEARCHRES RFC5182 */ public UidRange[] parseUidRange() throws DecodingException { CharacterValidator validator = new MessageSetCharValidator(); // Don't fail to parse id ranges which are enclosed by "(..)" // See IMAP-283 String nextWord = consumeWord(validator, true); int commaPos = nextWord.indexOf(','); if (commaPos == -1) { return new UidRange[] { parseUidRange(nextWord) }; } ArrayList<UidRange> rangeList = new ArrayList<>(); int pos = 0; while (commaPos != -1) { String range = nextWord.substring(pos, commaPos); UidRange set = parseUidRange(range); rangeList.add(set); pos = commaPos + 1; commaPos = nextWord.indexOf(',', pos); } String range = nextWord.substring(pos); rangeList.add(parseUidRange(range)); // merge the ranges to minimize the needed queries. // See IMAP-211 List<UidRange> merged = UidRange.mergeRanges(rangeList); return merged.toArray(new UidRange[merged.size()]); }
protected UidRange[] uidRanges(Collection<MessageRange> mRanges) { UidRange[] idRanges = new UidRange[mRanges.size()]; Iterator<MessageRange> mIt = mRanges.iterator(); int i = 0; while (mIt.hasNext()) { MessageRange mr = mIt.next(); UidRange ir; if (mr.getType() == Type.ONE) { ir = new UidRange(mr.getUidFrom()); } else { ir = new UidRange(mr.getUidFrom(), mr.getUidTo()); } idRanges[i++] = ir; } return idRanges; }
if (selected.existsCount() > 0) { for (UidRange range : uids) { MessageUid lowVal = range.getLowVal(); MessageUid highVal = range.getHighVal();
@Override public ImapResponseComposer sequenceSet(UidRange[] ranges) throws IOException { StringBuilder sb = new StringBuilder(); for (int i = 0; i < ranges.length; i++) { UidRange range = ranges[i]; sb.append(range.getFormattedString()); if (i + 1 < ranges.length) { sb.append(","); } } return message(sb.toString()); }
@Test public void mergeZeroRangeShouldOutputZeroRange() { assertThat(UidRange.mergeRanges(ImmutableList.of())).isEmpty(); }
@Test public void mergeShouldNotMergeRangeWithDistanceGreaterThen1() { List<UidRange> actual = UidRange .mergeRanges( ImmutableList.of( new UidRange(_1, _2), new UidRange(_4, _5))); assertThat(actual).containsOnly(new UidRange(_1, _2), new UidRange(_4, _5)); }
return new UidRange(MessageUid.MAX_VALUE); } else { long value = parseUnsignedInteger(range); return new UidRange(MessageUid.of(value)); return new UidRange(MessageUid.MAX_VALUE); } else if (val1 <= val2) { return new UidRange(MessageUid.of(val1), MessageUid.of(val2)); } else if (val1 == Long.MAX_VALUE) { return new UidRange(MessageUid.of(val2), MessageUid.MAX_VALUE); } else { return new UidRange(MessageUid.of(val2), MessageUid.of(val1));
@Test public void formattedStringShouldUseImapRangeNotationForRange() { assertThat(new UidRange(_1, _3).getFormattedString()).isEqualTo("1:3"); }