Remove mutable state from Evaluators and some related, poorly tested functions

Ical.Net.Tests/RecurrenceTests.cs

@@ -2892,9 +2892,6 @@ public void GetOccurrences1()
         evt.RecurrenceRules[0].ByHour.Add(9);
         evt.RecurrenceRules[0].ByHour.Add(12);
 
-        // Clear the evaluation so we can calculate recurrences again.
-        evt.ClearEvaluation();
-
         occurrences = evt.GetOccurrences(previousDateAndTime, end);
         Assert.That(occurrences, Has.Count.EqualTo(10));
 

Ical.Net/Calendar.cs

@@ -198,17 +198,6 @@ public VTimeZone AddTimeZone(VTimeZone tz)
     }
 
 
-    /// <summary>
-    /// Clears recurrence evaluations for recurring components.
-    /// </summary>
-    public void ClearEvaluation()
-    {
-        foreach (var recurrable in RecurringItems)
-        {
-            recurrable.ClearEvaluation();
-        }
-    }
-
     /// <summary>
     /// Returns a list of occurrences of each recurring component
     /// for the date provided (<paramref name="dt"/>).
@@ -405,4 +394,4 @@ public VTimeZone AddLocalTimeZone(DateTime earliestDateTimeToSupport, bool inclu
         this.AddChild(tz);
         return tz;
     }
-}
+}

Ical.Net/CalendarCollection.cs

@@ -39,14 +39,6 @@ public static CalendarCollection Load(TextReader tr)
         return collection;
     }
 
-    public void ClearEvaluation()
-    {
-        foreach (var iCal in this)
-        {
-            iCal.ClearEvaluation();
-        }
-    }
-
     public HashSet<Occurrence> GetOccurrences(IDateTime dt)
     {
         var occurrences = new HashSet<Occurrence>();
@@ -158,4 +150,4 @@ public override bool Equals(object obj)
         if (ReferenceEquals(this, obj)) return true;
         return obj.GetType() == GetType() && Equals((CalendarEvent) obj);
     }
-}
+}

Ical.Net/CalendarComponents/Alarm.cs

@@ -63,12 +63,9 @@
         set => Properties.Set(TriggerRelation.Key, value);
     }
 
-    protected virtual IList<AlarmOccurrence> Occurrences { get; set; }
-
     public Alarm()
     {
         Name = Components.Alarm;
-        Occurrences = new List<AlarmOccurrence>();
     }
 
     /// <summary>
@@ -77,13 +74,13 @@
     /// </summary>
     public virtual IList<AlarmOccurrence> GetOccurrences(IRecurringComponent rc, IDateTime fromDate, IDateTime toDate)
     {
-        Occurrences.Clear();
-
         if (Trigger == null)
         {
-            return Occurrences;
+            return [];
         }
 
+        var occurrences = new List<AlarmOccurrence>();
+
         // If the trigger is relative, it can recur right along with
         // the recurring items, otherwise, it happens once and
         // only once (at a precise time).
@@ -121,21 +118,21 @@
                     }
                 }
 
-                Occurrences.Add(new AlarmOccurrence(this, dt.Add(Trigger.Duration.Value), rc));
+                occurrences.Add(new AlarmOccurrence(this, dt.Add(Trigger.Duration.Value), rc));
             }
         }
         else
         {
             var dt = Trigger.DateTime.Copy<IDateTime>();
             dt.AssociatedObject = this;
-            Occurrences.Add(new AlarmOccurrence(this, dt, rc));
+            occurrences.Add(new AlarmOccurrence(this, dt, rc));
         }
 
         // If a REPEAT and DURATION value were specified,
         // then handle those repetitions here.
-        AddRepeatedItems();
+        AddRepeatedItems(occurrences);
 
-        return Occurrences;
+        return occurrences;
     }
 
     /// <summary>
@@ -165,19 +162,19 @@
     /// <c>DURATION</c> properties.  Each recurrence of the alarm will
     /// have its own set of generated repetitions.
     /// </summary>
-    protected virtual void AddRepeatedItems()
+    private void AddRepeatedItems(List<AlarmOccurrence> occurrences)
     {
-        var len = Occurrences.Count;
+        var len = occurrences.Count;
         for (var i = 0; i < len; i++)
         {
-            var ao = Occurrences[i];
+            var ao = occurrences[i];
             var alarmTime = ao.DateTime.Copy<IDateTime>();
 
             for (var j = 0; j < Repeat; j++)
             {
                 alarmTime = alarmTime.Add(Duration);
-                Occurrences.Add(new AlarmOccurrence(this, alarmTime.Copy<IDateTime>(), ao.Component));
+                occurrences.Add(new AlarmOccurrence(this, alarmTime.Copy<IDateTime>(), ao.Component));
             }
         }
     }
-}
+}

Ical.Net/CalendarComponents/CalendarEvent.cs

@@ -224,8 +224,6 @@ public string Transparency
         set => Properties.Set(TransparencyType.Key, value);
     }
 
-    private EventEvaluator _mEvaluator;
-
     /// <summary>
     /// Constructs an Event object, with an iCalObject
     /// (usually an iCalendar object) as its parent.
@@ -239,36 +237,9 @@ private void Initialize()
     {
         Name = EventStatus.Name;
 
-        _mEvaluator = new EventEvaluator(this);
-        SetService(_mEvaluator);
+        SetService(new EventEvaluator(this));
     }
 
-    /// <summary>
-    /// Use this method to determine if an event occurs on a given date.
-    /// <note type="caution">
-    ///     This event should be called only after the Evaluate
-    ///     method has calculated the dates for which this event occurs.
-    /// </note>
-    /// </summary>
-    /// <param name="dateTime">The date to test.</param>
-    /// <returns>True if the event occurs on the <paramref name="dateTime"/> provided, False otherwise.</returns>
-    public virtual bool OccursOn(IDateTime dateTime)
-    {
-        return _mEvaluator.Periods.Any(p => p.StartTime.Date == dateTime.Date || // It's the start date OR
-                                            (p.StartTime.Date <= dateTime.Date && // It's after the start date AND
-                                             (p.EndTime.HasTime && p.EndTime.Date >= dateTime.Date || // an end time was specified, and it's after the test date
-                                              (!p.EndTime.HasTime && p.EndTime.Date > dateTime.Date))));
-    }
-
-    /// <summary>
-    /// Use this method to determine if an event begins at a given date and time.
-    /// </summary>
-    /// <param name="dateTime">The date and time to test.</param>
-    /// <returns>True if the event begins at the given date and time</returns>
-    public virtual bool OccursAt(IDateTime dateTime)
-    {
-        return _mEvaluator.Periods.Any(p => p.StartTime.Equals(dateTime));
-    }
 
     /// <summary>
     /// Determines whether or not the <see cref="CalendarEvent"/> is actively displayed

Ical.Net/CalendarComponents/RecurringComponent.cs

@@ -178,8 +178,6 @@ protected override void OnDeserializing(StreamingContext context)
         Initialize();
     }
 
-    public virtual void ClearEvaluation() => RecurrenceUtil.ClearEvaluation(this);
-
     public virtual HashSet<Occurrence> GetOccurrences(IDateTime dt) => RecurrenceUtil.GetOccurrences(this, dt, EvaluationIncludesReferenceDate);
 
     public virtual HashSet<Occurrence> GetOccurrences(DateTime dt)
@@ -243,4 +241,4 @@ public override int GetHashCode()
             return hashCode;
         }
     }
-}
+}

Ical.Net/CalendarComponents/Todo.cs

@@ -160,9 +160,9 @@ public virtual bool IsCompleted(IDateTime currDt)
             }
 
             // Evaluate to the previous occurrence.
-            _mEvaluator.EvaluateToPreviousOccurrence(Completed, currDt);
+            var periods = _mEvaluator.EvaluateToPreviousOccurrence(Completed, currDt);
 
-            return _mEvaluator.Periods.Cast<Period>().All(p => !p.StartTime.GreaterThan(Completed) || !currDt.GreaterThanOrEqual(p.StartTime));
+            return periods.Cast<Period>().All(p => !p.StartTime.GreaterThan(Completed) || !currDt.GreaterThanOrEqual(p.StartTime));
         }
         return false;
     }
@@ -212,4 +212,4 @@ private void ExtrapolateTimes(int source)
             DtStart = Due.Subtract(Duration);
         }
     }
-}
+}

Ical.Net/Evaluation/Evaluator.cs

@@ -13,37 +13,16 @@
 
 public abstract class Evaluator : IEvaluator
 {
-    private DateTime _mEvaluationStartBounds = DateTime.MaxValue;
-    private DateTime _mEvaluationEndBounds = DateTime.MinValue;
-
     private ICalendarObject _mAssociatedObject;
-    private readonly ICalendarDataType _mAssociatedDataType;
-
-    protected HashSet<Period> MPeriods;
 
     protected Evaluator()
     {
         Initialize();
     }
 
-    protected Evaluator(ICalendarObject associatedObject)
-    {
-        _mAssociatedObject = associatedObject;
-
-        Initialize();
-    }
-
-    protected Evaluator(ICalendarDataType dataType)
-    {
-        _mAssociatedDataType = dataType;
-
-        Initialize();
-    }
-
     private void Initialize()
     {
         Calendar = CultureInfo.CurrentCulture.Calendar;
-        MPeriods = new HashSet<Period>();
     }
 
     protected IDateTime ConvertToIDateTime(DateTime dt, IDateTime referenceDate)
@@ -93,32 +72,11 @@
 
     public System.Globalization.Calendar Calendar { get; private set; }
 
-    public virtual DateTime EvaluationStartBounds
-    {
-        get => _mEvaluationStartBounds;
-        set => _mEvaluationStartBounds = value;
-    }
-
-    public virtual DateTime EvaluationEndBounds
-    {
-        get => _mEvaluationEndBounds;
-        set => _mEvaluationEndBounds = value;
-    }
-
     public virtual ICalendarObject AssociatedObject
     {
-        get => _mAssociatedObject ?? _mAssociatedDataType?.AssociatedObject;
+        get => _mAssociatedObject;
         protected set => _mAssociatedObject = value;
     }
 
-    public virtual HashSet<Period> Periods => MPeriods;
-
-    public virtual void Clear()
-    {
-        _mEvaluationStartBounds = DateTime.MaxValue;
-        _mEvaluationEndBounds = DateTime.MinValue;
-        MPeriods.Clear();
-    }
-
     public abstract HashSet<Period> Evaluate(IDateTime referenceDate, DateTime periodStart, DateTime periodEnd, bool includeReferenceDateInResults);
-}
+}

Ical.Net/Evaluation/EventEvaluator.cs

@@ -41,9 +41,9 @@ public EventEvaluator(CalendarEvent evt) : base(evt) { }
     public override HashSet<Period> Evaluate(IDateTime referenceTime, DateTime periodStart, DateTime periodEnd, bool includeReferenceDateInResults)
     {
         // Evaluate recurrences normally
-        base.Evaluate(referenceTime, periodStart, periodEnd, includeReferenceDateInResults);
+        var periods = base.Evaluate(referenceTime, periodStart, periodEnd, includeReferenceDateInResults);
 
-        foreach (var period in Periods)
+        foreach (var period in periods)
         {
             period.Duration = CalendarEvent.GetFirstDuration();
             period.EndTime = period.Duration == default
@@ -52,14 +52,14 @@ public override HashSet<Period> Evaluate(IDateTime referenceTime, DateTime perio
         }
 
         // Ensure each period has a duration
-        foreach (var period in Periods.Where(p => p.EndTime == null))
+        foreach (var period in periods.Where(p => p.EndTime == null))
         {
             period.Duration = CalendarEvent.GetFirstDuration();
             period.EndTime = period.Duration == default
                 ? period.StartTime
                 : period.StartTime.Add(CalendarEvent.GetFirstDuration());
         }
 
-        return Periods;
+        return periods;
     }
-}
+}

Ical.Net/Evaluation/IEvaluator.cs

@@ -16,40 +16,11 @@ public interface IEvaluator
     /// </summary>
     System.Globalization.Calendar Calendar { get; }
 
-    /// <summary>
-    /// The start bounds of the evaluation.  This gives
-    /// the first date/time that is covered by the evaluation.
-    /// This together with EvaluationEndBounds determines
-    /// what time frames have already been evaluated, so
-    /// duplicate evaluation doesn't occur.
-    /// </summary>
-    DateTime EvaluationStartBounds { get; }
-
-    /// <summary>
-    /// The end bounds of the evaluation.
-    /// See <see cref="EvaluationStartBounds"/> for more info.
-    /// </summary>
-    DateTime EvaluationEndBounds { get; }
-
-    /// <summary>
-    /// Gets a list of periods collected so far during
-    /// the evaluation process.
-    /// </summary>
-    HashSet<Period> Periods { get; }
-
     /// <summary>
     /// Gets the object associated with this evaluator.
     /// </summary>
     ICalendarObject AssociatedObject { get; }
 
-    /// <summary>
-    /// Clears the evaluation, eliminating all data that has
-    /// been collected up to this point.  Since this data is cached
-    /// as needed, this method can be useful to gather information
-    /// that is guaranteed to not be out-of-date.
-    /// </summary>
-    void Clear();
-
     /// <summary>
     /// Evaluates this item to determine the dates and times for which it occurs/recurs.
     /// This method only evaluates items which occur/recur between <paramref name="periodStart"/>
@@ -74,4 +45,4 @@ public interface IEvaluator
     ///     each date/time when this item occurs/recurs.
     /// </returns>
     HashSet<Period> Evaluate(IDateTime referenceDate, DateTime periodStart, DateTime periodEnd, bool includeReferenceDateInResults);
-}
+}

Ical.Net/Evaluation/RecurrencePatternEvaluator.cs

@@ -950,14 +950,11 @@ public override HashSet<Period> Evaluate(IDateTime referenceDate, DateTime perio
 
         // Enforce evaluation restrictions on the pattern.
         EnforceEvaluationRestrictions(pattern);
-        Periods.Clear();
 
         var periodQuery = GetDates(referenceDate, periodStart, periodEnd, -1, pattern, includeReferenceDateInResults)
             .Select(dt => CreatePeriod(dt, referenceDate));
 
-        Periods.UnionWith(periodQuery);
-
-        return Periods;
+        return new HashSet<Period>(periodQuery);
     }
 
     private static IDateTime MatchTimeZone(IDateTime dt1, IDateTime dt2)