Refactored to use streams

ical4j · Dec 8, 2018 · 43f9784 · 43f9784
1 parent ca3c6ff
commit 43f9784
Showing 1 changed file with 35 additions and 50 deletions.
diff --git a/src/main/java/net/fortuna/ical4j/model/Component.java b/src/main/java/net/fortuna/ical4j/model/Component.java
@@ -44,6 +44,7 @@
 import java.text.ParseException;
 import java.time.temporal.TemporalAmount;
 import java.util.List;
+import java.util.stream.Collectors;
 
 /**
  * $Id$ [Apr 5, 2004]
@@ -325,46 +326,31 @@ public final PeriodList calculateRecurrenceSet(final Period period) {
         } else {
             rDuration = duration.getDuration();
         }
-
-        List<RDate> rDates = getProperties(Property.RDATE);
+
         // add recurrence dates..
-        for (RDate rdate : rDates) {            
-            final Value rdateValue = rdate.getParameter(Parameter.VALUE);
-            if (Value.PERIOD.equals(rdateValue)) {
-                for (final Period rdatePeriod : rdate.getPeriods()) {
-                    if (period.intersects(rdatePeriod)) {
-                        recurrenceSet.add(rdatePeriod);
-                    }
-                }
-            } else if (Value.DATE_TIME.equals(rdateValue)) {
-                for (final Date rdateTime : rdate.getDates()) {
-                    if (period.includes(rdateTime)) {
-                        recurrenceSet.add(new Period((DateTime) rdateTime, rDuration));
-                    }
-                }
-            } else {
-                for (final Date rdateDate : rdate.getDates()) {
-                    if (period.includes(rdateDate)) {
-                        recurrenceSet.add(new Period(new DateTime(rdateDate), rDuration));
-                    }
-                }
-            }
-        }
+        List<RDate> rDates = getProperties(Property.RDATE);
+        recurrenceSet.addAll(rDates.stream().filter(p -> p.getParameter(Parameter.VALUE) == Value.PERIOD)
+                .map(p -> p.getPeriods()).flatMap(PeriodList::stream).filter(rdatePeriod -> period.intersects(rdatePeriod))
+                .collect(Collectors.toList()));
+
+        recurrenceSet.addAll(rDates.stream().filter(p -> p.getParameter(Parameter.VALUE) == Value.DATE_TIME)
+                .map(p -> p.getDates()).flatMap(DateList::stream).filter(date -> period.includes(date))
+                .map(rdateTime -> new Period((DateTime) rdateTime, rDuration)).collect(Collectors.toList()));
+
+        recurrenceSet.addAll(rDates.stream().filter(p -> p.getParameter(Parameter.VALUE) == Value.DATE)
+                .map(p -> p.getDates()).flatMap(DateList::stream).filter(date -> period.includes(date))
+                .map(rdateDate -> new Period(new DateTime(rdateDate), rDuration)).collect(Collectors.toList()));
 
         // allow for recurrence rules that start prior to the specified period
         // but still intersect with it..
         final DateTime startMinusDuration = new DateTime(period.getStart());
         startMinusDuration.setTime(Date.from(period.getStart().toInstant().minus(rDuration)).getTime());
 
         // add recurrence rules..
-        for (Property property2 : getProperties(Property.RRULE)) {
-            final RRule rrule = (RRule) property2;
-            final DateList rruleDates = rrule.getRecur().getDates(start.getDate(),
-                    new Period(startMinusDuration, period.getEnd()), startValue);
-            for (final Date rruleDate : rruleDates) {
-                recurrenceSet.add(new Period(new DateTime(rruleDate), rDuration));
-            }
-        }
+        List<RRule> rRules = getProperties(Property.RRULE);
+        recurrenceSet.addAll(rRules.stream().map(r -> r.getRecur().getDates(start.getDate(),
+                new Period(startMinusDuration, period.getEnd()), startValue)).flatMap(DateList::stream)
+                .map(rruleDate -> new Period(new DateTime(rruleDate), rDuration)).collect(Collectors.toList()));
 
         // add initial instance if intersection with the specified period..
         Period startPeriod;
@@ -388,26 +374,25 @@ public final PeriodList calculateRecurrenceSet(final Period period) {
         }
 
         // subtract exception dates..
-        for (Property property1 : getProperties(Property.EXDATE)) {
-            final ExDate exdate = (ExDate) property1;
-            recurrenceSet.removeIf(recurrence -> {
-                // for DATE-TIME instances check for DATE-based exclusions also..
-                return exdate.getDates().contains(recurrence.getStart())
-                        || exdate.getDates().contains(new Date(recurrence.getStart()));
-            });
-        }
+        List<ExDate> exDateProps = getProperties(Property.EXDATE);
+        List<Date> exDates = exDateProps.stream().map(e -> e.getDates()).flatMap(DateList::stream)
+                .collect(Collectors.toList());
+
+        recurrenceSet.removeIf(recurrence -> {
+            // for DATE-TIME instances check for DATE-based exclusions also..
+            return exDates.contains(recurrence.getStart()) || exDates.contains(new Date(recurrence.getStart()));
+        });
 
         // subtract exception rules..
-        for (Property property : getProperties(Property.EXRULE)) {
-            final ExRule exrule = (ExRule) property;
-            final DateList exruleDates = exrule.getRecur().getDates(start.getDate(),
-                    period, startValue);
-            recurrenceSet.removeIf(recurrence -> {
-                // for DATE-TIME instances check for DATE-based exclusions also..
-                return exruleDates.contains(recurrence.getStart())
-                        || exruleDates.contains(new Date(recurrence.getStart()));
-            });
-        }
+        List<ExRule> exRules = getProperties(Property.EXRULE);
+        List<Date> exRuleDates = exRules.stream().map(e -> e.getRecur().getDates(start.getDate(),
+                period, startValue)).flatMap(DateList::stream).collect(Collectors.toList());
+
+        recurrenceSet.removeIf(recurrence -> {
+            // for DATE-TIME instances check for DATE-based exclusions also..
+            return exRuleDates.contains(recurrence.getStart())
+                    || exRuleDates.contains(new Date(recurrence.getStart()));
+        });
 
         return recurrenceSet;
     }