@Override public Iterator<MessageUid> listAllMessageUids(Mailbox mailbox) throws MailboxException { return Iterators.transform(findInMailbox(mailbox, MessageRange.all(), FetchType.Metadata, UNLIMITED), MailboxMessage::getUid); } }
public MessageRange toRange() { return MessageRange.one(this); }
/** * Tries to split the given {@link MessageRange} to a {@link List} of {@link MessageRange}'s which * select only a max amount of items. This only work for {@link MessageRange}'s with {@link Type} of * {@link Type#RANGE}. */ public List<MessageRange> split(int maxItems) { List<MessageRange> ranges = new ArrayList<>(); if (getType() == Type.RANGE) { long from = getUidFrom().asLong(); long to = getUidTo().asLong(); long realTo = to; while (from <= realTo) { if (from + maxItems - 1 < realTo) { to = from + maxItems - 1; } else { to = realTo; } if (from == to) { ranges.add(MessageUid.of(from).toRange()); } else { ranges.add(MessageRange.range(MessageUid.of(from), MessageUid.of(to))); } from = to + 1; } } else { ranges.add(this); } return ranges; }
public StoreMessageResultIterator(MessageMapper mapper, Mailbox mailbox, MessageRange range, BatchSizes batchSizes, org.apache.james.mailbox.model.MessageResult.FetchGroup group) { this.mailbox = mailbox; this.group = group; this.mapper = mapper; this.from = range.getUidFrom(); this.cursor = this.from; this.to = range.getUidTo(); this.batchSizes = batchSizes; this.type = range.getType(); this.ftype = getFetchType(group); LOGGER.debug("batchSizes used: {}", batchSizes); }
/** * Return a read-only {@link Iterator} which contains all uid which fall in the specified range. */ @Override public Iterator<MessageUid> iterator() { return new RangeIterator(getUidFrom(), getUidTo()); }
private void readBatch() throws MailboxException { MessageRange range; switch (type) { default: case ALL: // In case of all, we start on cursor and don't specify a to range = MessageRange.from(cursor); break; case FROM: range = MessageRange.from(cursor); break; case ONE: range = MessageRange.one(cursor); break; case RANGE: range = MessageRange.range(cursor, to); break; } next = mapper.findInMailbox(mailbox, range, ftype, batchSizeFromFetchType(ftype)); }
MessageRange r = ranges.get(i); NumericRange nr; if (r.getType() == Type.ONE) { nr = new NumericRange(r.getUidFrom()); } else { nr = new NumericRange(r.getUidFrom(), r.getUidTo()); vanishedUids.remove(uids.next()); IdRange[] vanishedIdRanges = idRanges(MessageRange.toRanges(vanishedUids)); responder.respond(new VanishedResponse(vanishedIdRanges, true));
if (messageSet != null) { MessageRange normalizedMessageSet = normalizeMessageRange(session.getSelected(), messageSet); MessageRange batchedMessageSet = MessageRange.range(normalizedMessageSet.getUidFrom(), normalizedMessageSet.getUidTo()); ranges.add(batchedMessageSet);
private List<SearchResult> searchResults(MailboxSession session, Mailbox mailbox, SearchQuery query) throws MailboxException { MessageMapper mapper = messageMapperFactory.getMessageMapper(session); final SortedSet<MailboxMessage> hitSet = new TreeSet<>(); UidCriterion uidCrit = findConjugatedUidCriterion(query.getCriterias()); if (uidCrit != null) { // if there is a conjugated uid range criterion in the query tree we can optimize by // only fetching this uid range UidRange[] ranges = uidCrit.getOperator().getRange(); for (UidRange r : ranges) { Iterator<MailboxMessage> it = mapper.findInMailbox(mailbox, MessageRange.range(r.getLowValue(), r.getHighValue()), FetchType.Metadata, -1); while (it.hasNext()) { hitSet.add(it.next()); } } } else { // we have to fetch all messages Iterator<MailboxMessage> messages = mapper.findInMailbox(mailbox, MessageRange.all(), FetchType.Full, -1); while (messages.hasNext()) { MailboxMessage m = messages.next(); hitSet.add(m); } } return ImmutableList.copyOf(new MessageSearches(hitSet.iterator(), query, textExtractor).iterator()); }
public UidRange(MessageUid minValue, MessageUid messageUid) { if (minValue.compareTo(messageUid) > 0) { throw new IllegalArgumentException("LowVal must be <= HighVal"); } this.range = MessageRange.range(minValue, messageUid); }
/** * Return a {@link MessageRange} for the given values. If the MessageRange * can not be generated a {@link MailboxException} will get thrown */ protected MessageRange messageRange(SelectedMailbox selected, IdRange range, boolean useUids) throws MessageRangeException { long lowVal = range.getLowVal(); long highVal = range.getHighVal(); if (useUids == false) { return msnRangeToMessageRange(selected, lowVal, highVal); } else { if (selected.existsCount() <= 0) { return null; } // Take care of "*" and "*:*" values by return the last message in // the mailbox. See IMAP-289 MessageUid lastUid = selected.getLastUid().orElse(MessageUid.MIN_VALUE); if (lowVal == Long.MAX_VALUE && highVal == Long.MAX_VALUE) { return MessageRange.one(lastUid); } else if (highVal == Long.MAX_VALUE && lastUid.compareTo(MessageUid.of(lowVal)) < 0) { // Sequence uid ranges which use *:<uid-higher-then-last-uid> // MUST return at least the highest uid in the mailbox // See IMAP-291 return MessageRange.one(lastUid); } return MessageRange.range(MessageUid.of(lowVal), MessageUid.of(highVal)); } }
if (session.getAttribute(SEARCH_MODSEQ) != null) { MetaData metaData = mailbox.getMetaData(false, msession , MessageManager.MetaData.FetchGroup.NO_COUNT); highestModSeq = findHighestModSeq(msession, mailbox, MessageRange.toRanges(uids), metaData.getHighestModSeq()); idList.add(ids[i]); List<MessageRange> ranges = MessageRange.toRanges(idList); idRanges = new IdRange[ranges.size()]; for (int i = 0 ; i <ranges.size(); i++) { MessageRange range = ranges.get(i); idRanges[i] = new IdRange(range.getUidFrom(), range.getUidTo());
private void addVanishedResponse(SelectedMailbox selected, Collection<Long> expungedUids, final ImapProcessor.Responder responder) { for (final Long uid : expungedUids) { final long uidValue = uid.longValue(); selected.remove(uidValue); } IdRange[] uidRange = idRanges(MessageRange.toRanges(expungedUids)); responder.respond(new VanishedResponse(uidRange, false)); }
/** * Constructs an inclusive ranges of messages. The parameters will be * checked and {@link #from(long)} used where appropriate. * * @param from * first message UID * @param to * last message UID */ public static MessageRange range(MessageUid from, MessageUid to) { if (to.equals(MessageUid.MAX_VALUE) || to.compareTo(from) < 0) { return from(from); } else if (from.equals(to)) { // from and to is the same so no need to construct a real range return one(from); } else { return new MessageRange(Type.RANGE, from, to); } }
@Test public void splitTenElementsRangeShouldReturn4Ranges() { MessageRange range = MessageRange.range(MessageUid.of(1),MessageUid.of(10)); List<MessageRange> ranges = range.split(3); assertThat(ranges).containsExactly( MessageRange.range(MessageUid.of(1), MessageUid.of(3)), MessageRange.range(MessageUid.of(4), MessageUid.of(6)), MessageRange.range(MessageUid.of(7), MessageUid.of(9)), MessageUid.of(10).toRange()); }
public MessageUid getHighVal() { return range.getUidTo(); }
public MessageUid getLowVal() { return range.getUidFrom(); }