difference method

Implementation

@override
PackageVersionNumberGeneralLibraryConstraint difference(
    PackageVersionNumberGeneralLibraryConstraint other) {
  if (other.isEmpty) return this;

  if (other is PackageVersionNumberGeneralLibrary) {
    if (!allows(other)) return this;

    if (other == min) {
      if (!includeMin) return this;
      return PackageVersionNumberGeneralLibraryRange(
          min: min,
          max: max,
          includeMax: includeMax,
          alwaysIncludeMaxPreRelease: true);
    }

    if (other == max) {
      if (!includeMax) return this;
      return PackageVersionNumberGeneralLibraryRange(
          min: min,
          max: max,
          includeMin: includeMin,
          alwaysIncludeMaxPreRelease: true);
    }

    return PackageVersionNumberGeneralLibraryUnion.fromRanges([
      PackageVersionNumberGeneralLibraryRange(
          min: min,
          max: other,
          includeMin: includeMin,
          alwaysIncludeMaxPreRelease: true),
      PackageVersionNumberGeneralLibraryRange(
          min: other,
          max: max,
          includeMax: includeMax,
          alwaysIncludeMaxPreRelease: true)
    ]);
  } else if (other is PackageVersionNumberGeneralLibraryRange) {
    if (!allowsAny(other)) return this;

    PackageVersionNumberGeneralLibraryRange? before;
    if (!allowsLower(this, other)) {
      before = null;
    } else if (min == other.min) {
      assert(includeMin && !other.includeMin);
      assert(min != null);
      before = min;
    } else {
      before = PackageVersionNumberGeneralLibraryRange(
          min: min,
          max: other.min,
          includeMin: includeMin,
          includeMax: !other.includeMin,
          alwaysIncludeMaxPreRelease: true);
    }

    PackageVersionNumberGeneralLibraryRange? after;
    if (!allowsHigher(this, other)) {
      after = null;
    } else if (max == other.max) {
      assert(includeMax && !other.includeMax);
      assert(max != null);
      after = max;
    } else {
      after = PackageVersionNumberGeneralLibraryRange(
          min: other.max,
          max: max,
          includeMin: !other.includeMax,
          includeMax: includeMax,
          alwaysIncludeMaxPreRelease: true);
    }

    if (before == null && after == null) {
      return PackageVersionNumberGeneralLibraryConstraint.empty;
    }
    if (before == null) return after!;
    if (after == null) return before;
    return PackageVersionNumberGeneralLibraryUnion.fromRanges(
        [before, after]);
  } else if (other is PackageVersionNumberGeneralLibraryUnion) {
    var ranges = <PackageVersionNumberGeneralLibraryRange>[];
    var current = this;

    for (var range in other.ranges) {
      // Skip any ranges that are strictly lower than [current].
      if (strictlyLower(range, current)) continue;

      // If we reach a range strictly higher than [current], no more ranges
      // will be relevant so we can bail early.
      if (strictlyHigher(range, current)) break;

      var difference = current.difference(range);
      if (difference.isEmpty) {
        return PackageVersionNumberGeneralLibraryConstraint.empty;
      } else if (difference is PackageVersionNumberGeneralLibraryUnion) {
        // If [range] split [current] in half, we only need to continue
        // checking future ranges against the latter half.
        assert(difference.ranges.length == 2);
        ranges.add(difference.ranges.first);
        current = difference.ranges.last;
      } else {
        current = difference as PackageVersionNumberGeneralLibraryRange;
      }
    }

    if (ranges.isEmpty) return current;
    return PackageVersionNumberGeneralLibraryUnion.fromRanges(
        ranges..add(current));
  }

  throw ArgumentError(
      'Unknown PackageVersionNumberGeneralLibraryConstraint type $other.');
}