public DateRangeCollection Union(DateRangeCollection rhs) { /* * Simple case, since Normalize basically creates a union. * Hence, we don't really need any implementation, beyond * whatever logic the CTOR of the class contains, besides * from making sure we pass in both sides' content to the CTOR. */ var list = new List <DateRange>(_content); list.AddRange(rhs); return(new DateRangeCollection(Normalize(list))); }
public DateRangeCollection Intersection(DateRangeCollection rhs) { // Buffer used to hold our result. var list = new List <DateRange>(); /* * The iterator for the this instance, which is used to enumerate * all the instances in the this object. */ var selfIterator = GetEnumerator(); /* * The iterator for the rhs (argument) collection. * Notice, these iterators are incremented independently, * in such a way that each relevant instance in each * collection is compared for intersection towards the other * party's relevant instance(s). * * This algorithm assumes that both sides are sorted lists, * and normalized, which shouldn't be a problem, since creating * an instance of a DateTimeCollection is impossible without * also making sure it's normalized. */ var otherIterator = rhs.GetEnumerator(); /* * Verifying both sides have instances, since if not, the * obvious result would be an empty collection */ if (selfIterator.MoveNext() && otherIterator.MoveNext()) { /* * The body of our algorithm, which increments the correct * iterator, to make sure we only compare relevant instances. */ while (true) { var selfCurrent = selfIterator.Current; var otherCurrent = otherIterator.Current; // Checking for intersection. if (selfCurrent.Intersects(otherCurrent)) { list.Add(selfCurrent.Intersection(otherCurrent)); } /* * Which iterator we advance depends upon which item * has the largest End date, to make sure consecutive relevant * instances are compared towards all relevant instances * in the other collection. * * If any of the iterators yields no more results, we are * done, and no more additions are possible. */ if (selfCurrent.End > otherCurrent.End) { if (!otherIterator.MoveNext()) { break; } } else { if (!selfIterator.MoveNext()) { break; } } } } /* * Our end result, passed into our private CTOR, which assumes * the items are already normalized. */ return(new DateRangeCollection(list)); }