JAMES-2107 Run IntelliJ inspection: "Move from imperative to Stream API"

mailbox/api/src/main/java/org/apache/james/mailbox/model/FetchGroupImpl.java

@@ -86,19 +86,16 @@ public Set<PartContentDescriptor> getPartContentDescriptors() {
      */
     public void addPartContent(MimePath path, int content) {
         if (partContentDescriptors == null) {
-            partContentDescriptors = new HashSet<PartContentDescriptor>();
-        }
-        PartContentDescriptorImpl currentDescriptor = null;
-        for (PartContentDescriptor descriptor : partContentDescriptors) {
-            if (path.equals(descriptor.path())) {
-                currentDescriptor = (PartContentDescriptorImpl) descriptor;
-                break;
-            }
-        }
-        if (currentDescriptor == null) {
-            currentDescriptor = new PartContentDescriptorImpl(path);
-            partContentDescriptors.add(currentDescriptor);
+            partContentDescriptors = new HashSet<>();
         }
+        PartContentDescriptorImpl currentDescriptor = (PartContentDescriptorImpl) partContentDescriptors.stream()
+            .filter(descriptor -> path.equals(descriptor.path()))
+            .findFirst()
+            .orElseGet(() -> {
+                PartContentDescriptorImpl result = new PartContentDescriptorImpl(path);
+                partContentDescriptors.add(result);
+                return result;
+            });
 
         currentDescriptor.or(content);
     }

mailbox/hbase/src/main/java/org/apache/james/mailbox/hbase/mail/HBaseMailboxMessage.java

@@ -318,11 +318,7 @@ public long getHeaderOctets() {
      * This implementation supports user flags
      */
     public String[] createUserFlags() {
-        String[] flags = new String[userFlags.size()];
-        for (int i = 0; i < userFlags.size(); i++) {
-            flags[i] = userFlags.get(i);
-        }
-        return flags;
+        return userFlags.toArray(new String[userFlags.size()]);
     }
 
     @Override

mailbox/jcr/src/main/java/org/apache/james/mailbox/jcr/mail/model/JCRMailboxMessage.java

@@ -53,6 +53,8 @@
 import org.apache.james.mailbox.store.search.comparator.UidComparator;
 import org.slf4j.Logger;
 
+import com.github.steveash.guavate.Guavate;
+
 public class JCRMailboxMessage implements MailboxMessage, JCRImapConstants, Persistent {
 
     private static final Comparator<MailboxMessage> MESSAGE_UID_COMPARATOR = new UidComparator();
@@ -304,10 +306,9 @@ public void merge(Node node) throws RepositoryException, IOException {
 
 
             List<Property> currentProperties = getProperties();
-            List<Property> newProperties = new ArrayList<Property>();
-            for (Property prop : currentProperties) {
-                newProperties.add(new JCRProperty(prop, logger));
-            }
+            List<Property> newProperties = currentProperties.stream()
+                .map(prop -> new JCRProperty(prop, logger))
+                .collect(Guavate.toImmutableList());
             // remove old properties, we will add a bunch of new ones
             NodeIterator iterator = node.getNodes("messageProperty");
             while (iterator.hasNext()) {

mailbox/jpa/src/main/java/org/apache/james/mailbox/jpa/mail/model/openjpa/AbstractJPAMailboxMessage.java

@@ -463,11 +463,9 @@ public Flags createFlags() {
     }
 
     protected String[] createUserFlags() {
-        String[] flags = new String[userFlags.size()];
-        for (int i = 0; i < userFlags.size(); i++) {
-            flags[i] = userFlags.get(i).getName();
-        }
-        return flags;
+        return userFlags.stream()
+            .map(JPAUserFlag::getName)
+            .toArray(String[]::new);
     }
 
     /**

mailbox/maildir/src/main/java/org/apache/james/mailbox/maildir/UidConstraint.java

@@ -50,10 +50,8 @@ public UidConstraint between(long lower, long upper) {
     }
 
     public boolean isAllowed(long uid) {
-        for (Constraint constraint : constraints)
-            if (!constraint.isAllowed(uid))
-                return false;
-        return true;
+        return constraints.stream()
+            .allMatch(constraint -> constraint.isAllowed(uid));
     }
 
     public abstract static class Constraint {

mailbox/maildir/src/main/java/org/apache/james/mailbox/maildir/user/MaildirSubscriptionMapper.java

@@ -26,7 +26,6 @@
 import java.io.PrintWriter;
 import java.util.ArrayList;
 import java.util.Collections;
-import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
 
@@ -37,6 +36,10 @@
 import org.apache.james.mailbox.store.user.model.Subscription;
 import org.apache.james.mailbox.store.user.model.impl.SimpleSubscription;
 
+import com.github.steveash.guavate.Guavate;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Sets;
+
 public class MaildirSubscriptionMapper extends NonTransactionalMapper implements SubscriptionMapper {
 
     private static final String FILE_SUBSCRIPTION = "subscriptions";
@@ -53,10 +56,11 @@ public MaildirSubscriptionMapper(MaildirStore store) {
     public void delete(Subscription subscription) throws SubscriptionException {
      // TODO: we need some kind of file locking here
         Set<String> subscriptionNames = readSubscriptionsForUser(subscription.getUser());
-        boolean changed = subscriptionNames.remove(subscription.getMailbox());
+        Set<String> newSubscriptions = Sets.difference(subscriptionNames, ImmutableSet.of(subscription.getMailbox()));
+        boolean changed = subscriptionNames.size() != newSubscriptions.size();
         if (changed) {
             try {
-                writeSubscriptions(new File(store.userRoot(subscription.getUser())), subscriptionNames);
+                writeSubscriptions(new File(store.userRoot(subscription.getUser())), newSubscriptions);
             } catch (IOException e) {
                 throw new SubscriptionException(e);
             }
@@ -69,11 +73,9 @@ public void delete(Subscription subscription) throws SubscriptionException {
     @Override
     public List<Subscription> findSubscriptionsForUser(String user) throws SubscriptionException {
         Set<String> subscriptionNames = readSubscriptionsForUser(user);
-        ArrayList<Subscription> subscriptions = new ArrayList<Subscription>();
-        for (String subscription : subscriptionNames) {
-            subscriptions.add(new SimpleSubscription(user, subscription));
-        }
-        return subscriptions;
+        return subscriptionNames.stream()
+            .map(subscription -> new SimpleSubscription(user, subscription))
+            .collect(Guavate.toImmutableList());
     }
 
     /**
@@ -100,10 +102,14 @@ public Subscription findMailboxSubscriptionForUser(String user, String mailbox)
     public void save(Subscription subscription) throws SubscriptionException {
         // TODO: we need some kind of file locking here
         Set<String> subscriptionNames = readSubscriptionsForUser(subscription.getUser());
-        boolean changed = subscriptionNames.add(subscription.getMailbox());
+        Set<String> newSubscriptions = ImmutableSet.<String>builder()
+            .addAll(subscriptionNames)
+            .add(subscription.getMailbox())
+            .build();
+        boolean changed = subscriptionNames.size() != newSubscriptions.size();
         if (changed) {
             try {
-                writeSubscriptions(new File(store.userRoot(subscription.getUser())), subscriptionNames);
+                writeSubscriptions(new File(store.userRoot(subscription.getUser())), newSubscriptions);
             } catch (IOException e) {
                 throw new SubscriptionException(e);
             }
@@ -127,13 +133,11 @@ public void endRequest() {
      */
     private Set<String> readSubscriptionsForUser(String user) throws SubscriptionException { 
         File userRoot = new File(store.userRoot(user));
-        Set<String> subscriptionNames;
         try {
-            subscriptionNames = readSubscriptions(userRoot);
+            return readSubscriptions(userRoot);
         } catch (IOException e) {
             throw new SubscriptionException(e);
         }
-        return subscriptionNames;
     }
 
     /**
@@ -144,16 +148,14 @@ private Set<String> readSubscriptionsForUser(String user) throws SubscriptionExc
      */
     private Set<String> readSubscriptions(File mailboxFolder) throws IOException {
         File subscriptionFile = new File(mailboxFolder, FILE_SUBSCRIPTION);
-        HashSet<String> subscriptions = new HashSet<String>();
         if (!subscriptionFile.exists()) {
-            return subscriptions;
+            return ImmutableSet.of();
         }
         FileReader fileReader = new FileReader(subscriptionFile);
         BufferedReader reader = new BufferedReader(fileReader);
-        String subscription;
-        while ((subscription = reader.readLine()) != null)
-            if (!subscription.equals(""))
-                subscriptions.add(subscription);
+        Set<String> subscriptions = reader.lines()
+            .filter(subscription -> !subscription.equals(""))
+            .collect(Guavate.toImmutableSet());
         reader.close();
         fileReader.close();
         return subscriptions;

mailbox/memory/src/main/java/org/apache/james/mailbox/inmemory/mail/InMemoryMailboxMapper.java

@@ -34,6 +34,7 @@
 import org.apache.james.mailbox.store.mail.model.Mailbox;
 import org.apache.james.mailbox.store.mail.model.impl.SimpleMailbox;
 
+import com.github.steveash.guavate.Guavate;
 import com.google.common.base.Objects;
 
 public class InMemoryMailboxMapper implements MailboxMapper {
@@ -84,13 +85,11 @@ public synchronized Mailbox findMailboxById(MailboxId id) throws MailboxExceptio
      */
     public List<Mailbox> findMailboxWithPathLike(MailboxPath path) throws MailboxException {
         final String regex = path.getName().replace("%", ".*");
-        List<Mailbox> results = new ArrayList<Mailbox>();
-        for (Mailbox mailbox: mailboxesByPath.values()) {
-            if (mailboxMatchesRegex(mailbox, path, regex)) {
-                results.add(new SimpleMailbox(mailbox));
-            }
-        }
-        return results;
+        return mailboxesByPath.values()
+            .stream()
+            .filter(mailbox -> mailboxMatchesRegex(mailbox, path, regex))
+            .map(SimpleMailbox::new)
+            .collect(Guavate.toImmutableList());
     }
 
     private boolean mailboxMatchesRegex(Mailbox mailbox, MailboxPath path, String regex) {
@@ -134,12 +133,9 @@ public void endRequest() {
      */
     public boolean hasChildren(Mailbox mailbox, char delimiter) throws MailboxException {
         String mailboxName = mailbox.getName() + delimiter;
-        for (Mailbox box: mailboxesByPath.values()) {
-            if (belongsToSameUser(mailbox, box) && box.getName().startsWith(mailboxName)) {
-                return true;
-            }
-        }
-        return false;
+        return mailboxesByPath.values()
+            .stream()
+            .anyMatch(box -> belongsToSameUser(mailbox, box) && box.getName().startsWith(mailboxName));
     }
 
     private boolean belongsToSameUser(Mailbox mailbox, Mailbox otherMailbox) {

mailbox/memory/src/main/java/org/apache/james/mailbox/inmemory/mail/InMemoryMessageMapper.java

@@ -45,6 +45,8 @@
 import org.apache.james.mailbox.store.mail.model.impl.SimpleMailboxMessage;
 import org.apache.james.mailbox.store.mail.utils.ApplicableFlagCalculator;
 
+import com.github.steveash.guavate.Guavate;
+
 public class InMemoryMessageMapper extends AbstractMessageMapper {
     private final Map<InMemoryId, Map<MessageUid, MailboxMessage>> mailboxByUid;
     private static final int INITIAL_SIZE = 256;
@@ -75,13 +77,10 @@ public long countMessagesInMailbox(Mailbox mailbox) throws MailboxException {
 
     @Override
     public long countUnseenMessagesInMailbox(Mailbox mailbox) throws MailboxException {
-        long count = 0;
-        for (MailboxMessage member : getMembershipByUidForMailbox(mailbox).values()) {
-            if (!member.isSeen()) {
-                count++;
-            }
-        }
-        return count;
+        return getMembershipByUidForMailbox(mailbox).values()
+            .stream()
+            .filter(member -> !member.isSeen())
+            .count();
     }
 
     @Override
@@ -118,27 +117,23 @@ public Iterator<MailboxMessage> findInMailbox(Mailbox mailbox, MessageRange set,
 
     @Override
     public List<MessageUid> findRecentMessageUidsInMailbox(Mailbox mailbox) throws MailboxException {
-        final List<MessageUid> results = new ArrayList<MessageUid>();
-        for (MailboxMessage member : getMembershipByUidForMailbox(mailbox).values()) {
-            if (member.isRecent()) {
-                results.add(member.getUid());
-            }
-        }
-        Collections.sort(results);
-
-        return results;
+        return getMembershipByUidForMailbox(mailbox).values()
+            .stream()
+            .filter(MailboxMessage::isRecent)
+            .map(MailboxMessage::getUid)
+            .sorted()
+            .collect(Guavate.toImmutableList());
     }
 
     @Override
     public MessageUid findFirstUnseenMessageUid(Mailbox mailbox) throws MailboxException {
         List<MailboxMessage> memberships = new ArrayList<MailboxMessage>(getMembershipByUidForMailbox(mailbox).values());
         Collections.sort(memberships);
-        for (MailboxMessage m : memberships) {
-            if (m.isSeen() == false) {
-                return m.getUid();
-            }
-        }
-        return null;
+        return memberships.stream()
+            .filter(m -> !m.isSeen())
+            .findFirst()
+            .map(MailboxMessage::getUid)
+            .orElse(null);
     }
 
     @Override

mailbox/memory/src/main/java/org/apache/james/mailbox/inmemory/user/InMemorySubscriptionMapper.java

@@ -48,16 +48,13 @@ public synchronized void delete(Subscription subscription) {
 
     public Subscription findMailboxSubscriptionForUser(String user, String mailbox) {
         final List<Subscription> subscriptions = subscriptionsByUser.get(user);
-        Subscription result = null;
         if (subscriptions != null) {
-            for(Subscription subscription:subscriptions) {
-                if (subscription.getMailbox().equals(mailbox)) {
-                    result = subscription;
-                    break;
-                }
-            }
+            return subscriptions.stream()
+                .filter(subscription -> subscription.getMailbox().equals(mailbox))
+                .findFirst()
+                .orElse(null);
         }
-        return result;
+        return null;
     }
 
     public List<Subscription> findSubscriptionsForUser(String user) {

mailbox/store/pom.xml

@@ -72,6 +72,10 @@
             <groupId>commons-lang</groupId>
             <artifactId>commons-lang</artifactId>
         </dependency>
+        <dependency>
+            <groupId>com.github.steveash.guavate</groupId>
+            <artifactId>guavate</artifactId>
+        </dependency>
         <dependency>
             <groupId>com.google.guava</groupId>
             <artifactId>guava</artifactId>

mailbox/store/src/main/java/org/apache/james/mailbox/store/StoreMailboxManager.java

@@ -84,6 +84,7 @@
 import org.apache.james.mailbox.store.transaction.TransactionalMapper;
 import org.slf4j.Logger;
 
+import com.github.steveash.guavate.Guavate;
 import com.google.common.base.Optional;
 import com.google.common.base.Predicate;
 import com.google.common.collect.FluentIterable;
@@ -775,13 +776,11 @@ public void startProcessingRequest(MailboxSession session) {
 
     @Override
     public List<MailboxPath> list(MailboxSession session) throws MailboxException {
-        List<MailboxPath> mList = new ArrayList<MailboxPath>();
-        List<Mailbox> mailboxes = mailboxSessionMapperFactory.getMailboxMapper(session).list();
-        for (Mailbox m : mailboxes) {
-            mList.add(m.generateAssociatedPath());
-        }
-        return Collections.unmodifiableList(mList);
-
+        return mailboxSessionMapperFactory.getMailboxMapper(session)
+            .list()
+            .stream()
+            .map(Mailbox::generateAssociatedPath)
+            .collect(Guavate.toImmutableList());
     }
 
     @Override

mailbox/store/src/main/java/org/apache/james/mailbox/store/StoreSubscriptionManager.java

@@ -20,7 +20,7 @@
 
 import java.util.Collection;
 import java.util.HashSet;
-import java.util.List;
+import java.util.stream.Collectors;
 
 import javax.inject.Inject;
 
@@ -88,13 +88,11 @@ protected Subscription createSubscription(MailboxSession session, String mailbox
      * @see org.apache.james.mailbox.SubscriptionManager#subscriptions(org.apache.james.mailbox.MailboxSession)
      */
     public Collection<String> subscriptions(MailboxSession session) throws SubscriptionException {
-        final SubscriptionMapper mapper = mapperFactory.getSubscriptionMapper(session);
-        final List<Subscription> subscriptions = mapper.findSubscriptionsForUser(session.getUser().getUserName());
-        final Collection<String> results = new HashSet<String>(INITIAL_SIZE);
-        for (Subscription subscription:subscriptions) {
-            results.add(subscription.getMailbox());
-        }        
-        return results;
+        return mapperFactory.getSubscriptionMapper(session)
+            .findSubscriptionsForUser(session.getUser().getUserName())
+            .stream()
+            .map(Subscription::getMailbox)
+            .collect(Collectors.toCollection(() -> new HashSet<>(INITIAL_SIZE)));
     }
 
     /**