/// <summary>
/// Returns the minimum and maximum values in a stream.
/// </summary>
/// <typeparam name="T">The type of the stream.</typeparam>
/// <param name="that">The stream.</param>
/// <returns>The range of values in the stream.</returns>
public static Range <T> GetRange <T>(this IEnumerable <T> that)
where T : IComparable
{
IEnumerator <T> enumerator = that.GetEnumerator();
if (!enumerator.MoveNext())
{
return(new Range <T>());
}
T minimum = enumerator.Current;
T maximum = minimum;
while (enumerator.MoveNext())
{
T current = enumerator.Current;
if (ValueHelper.Compare(minimum, current) == 1)
{
minimum = current;
}
if (ValueHelper.Compare(maximum, current) == -1)
{
maximum = current;
}
}
return(new Range <T>(minimum, maximum));
}
/////// <summary>
/////// Returns a new range that contains the value.
/////// </summary>
/////// <param name="value">The value to extend the range to.</param>
/////// <returns>The range which contains the value.</returns>
////public Range<T> ExtendTo(T value)
////{
//// if (!HasData)
//// {
//// return new Range<T>(value, value);
//// }
//// if (ValueHelper.Compare(Minimum, value) > 0)
//// {
//// return new Range<T>(value, Maximum);
//// }
//// else if (ValueHelper.Compare(Maximum, value) < 0)
//// {
//// return new Range<T>(Minimum, value);
//// }
//// return this;
////}
/// <summary>
/// Returns a value indicating whether two ranges intersect.
/// </summary>
/// <param name="range">The range to compare against this range.</param>
/// <returns>A value indicating whether the ranges intersect.</returns>
public bool IntersectsWith(Range <T> range)
{
if (!this.HasData || !range.HasData)
{
return(false);
}
Func <Range <T>, Range <T>, bool> rightCollidesWithLeft =
(leftRange, rightRange) =>
(ValueHelper.Compare(rightRange.Minimum, leftRange.Maximum) <= 0 && ValueHelper.Compare(rightRange.Minimum, leftRange.Minimum) >= 0) ||
(ValueHelper.Compare(leftRange.Minimum, rightRange.Maximum) <= 0 && ValueHelper.Compare(leftRange.Minimum, rightRange.Minimum) >= 0);
return(rightCollidesWithLeft(this, range) || rightCollidesWithLeft(range, this));
}
/// <summary>
/// Adds a range to the current range.
/// </summary>
/// <param name="range">A range to add to the current range.</param>
/// <returns>A new range that encompasses the instance range and the
/// range parameter.</returns>
public Range <T> Add(Range <T> range)
{
if (!this.HasData)
{
return(range);
}
else if (!range.HasData)
{
return(this);
}
T minimum = ValueHelper.Compare(this.Minimum, range.Minimum) == -1 ? this.Minimum : range.Minimum;
T maximum = ValueHelper.Compare(this.Maximum, range.Maximum) == 1 ? this.Maximum : range.Maximum;
return(new Range <T>(minimum, maximum));
}
/// <summary>
/// Initializes a new instance of the Range class.
/// </summary>
/// <param name="minimum">The minimum value.</param>
/// <param name="maximum">The maximum value.</param>
public Range(T minimum, T maximum)
{
if (minimum == null)
{
throw new ArgumentNullException("minimum");
}
if (maximum == null)
{
throw new ArgumentNullException("maximum");
}
_hasData = true;
_minimum = minimum;
_maximum = maximum;
int compareValue = ValueHelper.Compare(minimum, maximum);
if (compareValue == 1)
{
throw new InvalidOperationException(Properties.Resources.Range_ctor_MaximumValueMustBeLargerThanOrEqualToMinimumValue);
}
}
/// <summary>
/// Returns the minimum and maximum values in a stream.
/// </summary>
/// <typeparam name="T">The type of the stream.</typeparam>
/// <param name="that">The stream.</param>
/// <returns>The range of values in the stream.</returns>
public static Range <T> GetRange <T>(this IEnumerable <T> that)
where T : IComparable
{
if (that.IsEmpty())
{
return(new Range <T>());
}
T minimum = that.First();
T maximum = minimum;
foreach (T value in that)
{
if (ValueHelper.Compare(minimum, value) == 1)
{
minimum = value;
}
if (ValueHelper.Compare(maximum, value) == -1)
{
maximum = value;
}
}
return(new Range <T>(minimum, maximum));
}
/// <summary>
/// Returns a value indicating whether a value is within a range.
/// </summary>
/// <param name="value">The value.</param>
/// <returns>Whether the value is within the range.</returns>
public bool Contains(T value)
{
return(ValueHelper.Compare(Minimum, value) <= 0 && ValueHelper.Compare(value, Maximum) <= 0);
}
