Remove QUIC's Interval::difference.

net/quic/core/interval.h

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 //
 // An Interval<T> is a data structure used to represent a contiguous, mutable
 // range over an ordered type T. Supported operations include testing a value to
 // see whether it is included in the interval, comparing two intervals, and
 // performing their union, intersection, and difference. For the purposes of
 // this library, an "ordered type" is any type that induces a total order on its
 // values via its less-than operator (operator<()). Examples of such types are
@@ skipping 139 matching lines @@
   bool Intersects(const Interval& i, Interval* out) const;
 
   // Sets *this to be the intersection of itself with i. Returns true iff
   // *this was modified.
   bool IntersectWith(const Interval& i);
 
   // Calculates the smallest interval containing both *this i, and updates *this
   // to represent that interval, and returns true iff *this was modified.
   bool SpanningUnion(const Interval& i);
 
-  // Determines the difference between two intervals by finding all points that
-  // are contained in *this but not in i, coalesces those points into the
-  // largest possible contiguous intervals, and appends those intervals to the
-  // *difference vector. Intuitively this can be thought of as "erasing" i from
-  // *this. This will either completely erase *this (leaving nothing behind),
-  // partially erase some of *this from the left or right side (leaving some
-  // residual behind), or erase a hole in the middle of *this (leaving behind an
-  // interval on either side). Therefore, 0, 1, or 2 intervals will be appended
-  // to *difference. The method returns true iff the intersection of *this and i
-  // is non-empty. The caller owns the vector and the Interval* pointers
-  // inside it. The difference vector is required to be non-null.
-  bool Difference(const Interval& i, std::vector<Interval*>* difference) const;
-
   // Determines the difference between two intervals as in
   // Difference(Interval&, vector*), but stores the results directly in out
   // parameters rather than dynamically allocating an Interval* and appending
   // it to a vector. If two results are generated, the one with the smaller
   // value of min() will be stored in *lo and the other in *hi. Otherwise (if
   // fewer than two results are generated), unused arguments will be set to the
   // empty interval (it is possible that *lo will be empty and *hi non-empty).
   // The method returns true iff the intersection of *this and i is non-empty.
   bool Difference(const Interval& i, Interval* lo, Interval* hi) const;
 
@@ skipping 76 matching lines @@
   }
   if (i.max() > max()) {
     SetMax(i.max());
     modified = true;
   }
   return modified;
 }
 
 template <typename T>
 bool Interval<T>::Difference(const Interval& i,
-                             std::vector<Interval*>* difference) const {
-  if (Empty()) {
-    // <empty> - <i> = <empty>
-    return false;
-  }
-  if (i.Empty()) {
-    // <this> - <empty> = <this>
-    difference->push_back(new Interval(*this));
-    return false;
-  }
-  if (min() < i.max() && min() >= i.min() && max() > i.max()) {
-    //            [------ this ------)
-    // [------ i ------)
-    //                 [-- result ---)
-    difference->push_back(new Interval(i.max(), max()));
-    return true;
-  }
-  if (max() > i.min() && max() <= i.max() && min() < i.min()) {
-    // [------ this ------)
-    //            [------ i ------)
-    // [- result -)
-    difference->push_back(new Interval(min(), i.min()));
-    return true;
-  }
-  if (min() < i.min() && max() > i.max()) {
-    // [------- this --------)
-    //      [---- i ----)
-    // [ R1 )           [ R2 )
-    // There are two results: R1 and R2.
-    difference->push_back(new Interval(min(), i.min()));
-    difference->push_back(new Interval(i.max(), max()));
-    return true;
-  }
-  if (min() >= i.min() && max() <= i.max()) {
-    //   [--- this ---)
-    // [------ i --------)
-    // Intersection is <this>, so difference yields the empty interval.
-    // Nothing is appended to *difference.
-    return true;
-  }
-  // No intersection. Append <this>.
-  difference->push_back(new Interval(*this));
-  return false;
-}
-
-template <typename T>
-bool Interval<T>::Difference(const Interval& i,
                              Interval* lo,
                              Interval* hi) const {
   // Initialize *lo and *hi to empty
   *lo = {};
   *hi = {};
   if (Empty())
     return false;
   if (i.Empty()) {
     *lo = *this;
     return false;
@@ skipping 27 matching lines @@
     // Intersection is <this>, so difference yields the empty interval.
     return true;
   }
   *lo = *this;  // No intersection.
   return false;
 }
 
 }  // namespace net
 
 #endif  // NET_QUIC_INTERVAL_H_